ronin-core 0.1.0.beta1

data/spec/cli/command_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'ronin/core/cli/command'
+
+describe Ronin::Core::CLI::Command do
+  it "must inherit from CommandKit::Command" do
+    expect(described_class).to be < CommandKit::Command
+  end
+
+  it "must include CommandKit::Help::Man" do
+    expect(described_class).to include(CommandKit::Help::Man)
+  end
+
+  it "must include CommandKit::BugReport" do
+    expect(described_class).to include(CommandKit::BugReport)
+  end
+end

data/spec/cli/fixtures/irb_command

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+
+$LOAD_PATH.unshift(File.expand_path(File.join(__dir__,'..','..','..','lib')))
+require 'ronin/core/cli/ruby_shell'
+
+Ronin::Core::CLI::RubyShell.start

data/spec/cli/fixtures/template/dir/file1.txt

@@ -0,0 +1 @@
+test1

data/spec/cli/fixtures/template/dir/file2.txt

@@ -0,0 +1 @@
+test2

data/spec/cli/fixtures/template/file.erb

@@ -0,0 +1 @@
+1 + 1 = <%= 1 + 1 -%>

data/spec/cli/fixtures/template/file.txt

@@ -0,0 +1 @@
+test

data/spec/cli/generator/options/author_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+require 'ronin/core/cli/generator/options/author'
+require 'ronin/core/cli/command'
+require 'ronin/core/cli/generator'
+
+describe Ronin::Core::CLI::Generator::Options::Author do
+  module TestAuthorOption
+    class TestCommand < Ronin::Core::CLI::Command
+      include Ronin::Core::CLI::Generator
+      include Ronin::Core::CLI::Generator::Options::Author
+
+      template_dir 'test'
+    end
+  end
+
+  let(:command_class) { TestAuthorOption::TestCommand }
+  subject { command_class.new }
+
+  let(:name)  { 'Foo Bar' }
+  let(:email) { 'foo.bar@example.com' }
+
+  describe ".defaultor_name" do
+    subject { described_class }
+
+    context "when `git config user.name` is set" do
+      before { allow(Ronin::Core::Git).to receive(:user_name).and_return(name) }
+
+      it "must use `git config user.name`" do
+        expect(subject.default_name).to eq(name)
+      end
+    end
+    
+    context "when `git config user.name` isn't set" do
+      before { allow(Ronin::Core::Git).to receive(:user_name).and_return(nil) }
+
+      it "must fallback to using the USERNAME environment variable" do
+        expect(subject.default_name).to eq(ENV['USERNAME'])
+      end
+    end
+  end
+
+  describe ".default_email" do
+    subject { described_class }
+
+    before { allow(Ronin::Core::Git).to receive(:user_email).and_return(email) }
+
+    it "must use `git config user.email`" do
+      expect(subject.default_email).to eq(email)
+    end
+  end
+
+  describe ".included" do
+    subject { command_class }
+
+    it "must add a '-a,--author NAME' option" do
+      expect(subject.options[:author]).to_not be_nil
+      expect(subject.options[:author].short).to eq('-a')
+      expect(subject.options[:author].value).to_not be_nil
+      expect(subject.options[:author].value.default.call).to eq(described_class.default_name)
+      expect(subject.options[:author].value.type).to eq(String)
+      expect(subject.options[:author].value.usage).to eq('NAME')
+
+      if (default_name = described_class.default_name)
+        expect(subject.options[:author].desc).to eq("The name of the author (Default: #{default_name})")
+      else
+        expect(subject.options[:author].desc).to eq("The name of the author")
+      end
+
+      expect(subject.options[:author].block).to_not be_nil
+    end
+
+    it "must add a '-e,--author-email EMAIL' option" do
+      expect(subject.options[:author_email]).to_not be_nil
+      expect(subject.options[:author_email].short).to eq('-e')
+      expect(subject.options[:author_email].value).to_not be_nil
+      expect(subject.options[:author_email].value.default.call).to eq(described_class.default_email)
+      expect(subject.options[:author_email].value.type).to eq(String)
+      expect(subject.options[:author_email].value.usage).to eq('EMAIL')
+
+      if (default_email = described_class.default_email)
+        expect(subject.options[:author_email].desc).to eq("The email address of the author (Default: #{default_email})")
+      else
+        expect(subject.options[:author_email].desc).to eq("The email address of the author")
+      end
+
+      expect(subject.options[:author_email].block).to_not be_nil
+    end
+  end
+
+  describe "#initialize" do
+    it "must set #author_name to #{described_class}.default_name" do
+      expect(subject.author_name).to eq(described_class.default_name)
+    end
+
+    it "must set #author_email to #{described_class}.default_email" do
+      expect(subject.author_email).to eq(described_class.default_email)
+    end
+  end
+
+  describe "#parse_options" do
+    context "when given '--author NAME'" do
+      let(:argv) { ['--author', name] }
+
+      before { subject.parse_options(argv) }
+
+      it "must set #uathor_name" do
+        expect(subject.author_name).to eq(name)
+      end
+    end
+
+    context "when given '--author-email NAME'" do
+      let(:argv) { ['--author-email', email] }
+
+      before { subject.parse_options(argv) }
+
+      it "must set #uathor_email" do
+        expect(subject.author_email).to eq(email)
+      end
+    end
+  end
+end

data/spec/cli/generator/options/description_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'ronin/core/cli/generator/options/description'
+require 'ronin/core/cli/command'
+require 'ronin/core/cli/generator'
+
+describe Ronin::Core::CLI::Generator::Options::Description do
+  module TestDescriptionOption
+    class TestCommand < Ronin::Core::CLI::Command
+      include Ronin::Core::CLI::Generator
+      include Ronin::Core::CLI::Generator::Options::Description
+
+      template_dir 'test'
+    end
+  end
+
+  let(:command_class) { TestDescriptionOption::TestCommand }
+  subject { command_class.new }
+
+  let(:description) { 'Foo bar baz' }
+
+  describe ".included" do
+    subject { command_class }
+
+    it "must add a '-D,--description TEXT' option" do
+      expect(subject.options[:description]).to_not be_nil
+      expect(subject.options[:description].short).to eq('-D')
+      expect(subject.options[:description].value).to_not be_nil
+      expect(subject.options[:description].value.type).to eq(String)
+      expect(subject.options[:description].value.usage).to eq('TEXT')
+      expect(subject.options[:description].desc).to eq('A longer description')
+    end
+  end
+
+  describe "#parse_options" do
+    context "when given '--description TEXT'" do
+      let(:argv) { ['--description', description] }
+
+      before { subject.parse_options(argv) }
+
+      it "must set #description" do
+        expect(subject.description).to eq(description)
+      end
+    end
+  end
+end

data/spec/cli/generator/options/reference_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'ronin/core/cli/generator/options/reference'
+require 'ronin/core/cli/command'
+require 'ronin/core/cli/generator'
+
+describe Ronin::Core::CLI::Generator::Options::Reference do
+  module TestReferenceOption
+    class TestCommand < Ronin::Core::CLI::Command
+      include Ronin::Core::CLI::Generator
+      include Ronin::Core::CLI::Generator::Options::Reference
+
+      template_dir 'test'
+    end
+  end
+
+  let(:command_class) { TestReferenceOption::TestCommand }
+  subject { command_class.new }
+
+  let(:url1) { 'https://example.com/link1' }
+  let(:url2) { 'https://example.com/link2' }
+
+  describe ".included" do
+    subject { command_class }
+
+    it "must add a '-R,--reference URL' option" do
+      expect(subject.options[:reference]).to_not be_nil
+      expect(subject.options[:reference].short).to eq('-R')
+      expect(subject.options[:reference].value).to_not be_nil
+      expect(subject.options[:reference].value.type).to eq(String)
+      expect(subject.options[:reference].value.usage).to eq('URL')
+      expect(subject.options[:reference].desc).to eq('Adds a reference URL')
+      expect(subject.options[:reference].block).to_not be_nil
+    end
+  end
+
+  describe "#initialize" do
+    it "must initialize #references to an empty Array" do
+      expect(subject.references).to eq([])
+    end
+  end
+
+  describe "#parse_options" do
+    context "when given '--reference URL'" do
+      let(:argv) { ['--reference', url1, '--reference', url2] }
+
+      before { subject.parse_options(argv) }
+
+      it "must append the URLs to #references" do
+        expect(subject.references).to eq([url1, url2])
+      end
+    end
+  end
+end

data/spec/cli/generator/options/summary_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'ronin/core/cli/generator/options/summary'
+require 'ronin/core/cli/command'
+require 'ronin/core/cli/generator'
+
+describe Ronin::Core::CLI::Generator::Options::Summary do
+  module TestSummaryOption
+    class TestCommand < Ronin::Core::CLI::Command
+      include Ronin::Core::CLI::Generator
+      include Ronin::Core::CLI::Generator::Options::Summary
+
+      template_dir 'test'
+    end
+  end
+
+  let(:command_class) { TestSummaryOption::TestCommand }
+  subject { command_class.new }
+
+  let(:summary) { 'Foo bar baz' }
+
+  describe ".included" do
+    subject { command_class }
+
+    it "must add a '-S,--summary TEXT' option" do
+      expect(subject.options[:summary]).to_not be_nil
+      expect(subject.options[:summary].short).to eq('-S')
+      expect(subject.options[:summary].value).to_not be_nil
+      expect(subject.options[:summary].value.type).to eq(String)
+      expect(subject.options[:summary].value.usage).to eq('TEXT')
+      expect(subject.options[:summary].desc).to eq('One sentence summary')
+    end
+  end
+
+  describe "#parse_options" do
+    context "when given '--summary TEXT'" do
+      let(:argv) { ['--summary', summary] }
+
+      before { subject.parse_options(argv) }
+
+      it "must set #summary" do
+        expect(subject.summary).to eq(summary)
+      end
+    end
+  end
+end

data/spec/cli/generator_spec.rb

@@ -0,0 +1,244 @@
+require 'spec_helper'
+require 'ronin/core/cli/generator'
+
+describe Ronin::Core::CLI::Generator do
+  module TestGenerator
+    class WithoutTemplateDir < Ronin::Core::CLI::Command
+      include Ronin::Core::CLI::Generator
+    end
+
+    class WithTemplateDir < Ronin::Core::CLI::Command
+
+      include Ronin::Core::CLI::Generator
+
+      template_dir File.join(__dir__,'fixtures','template')
+
+    end
+
+    class InheritedTemplateDir < WithTemplateDir
+    end
+  end
+
+  let(:command_class) { TestGenerator::WithTemplateDir }
+  subject { command_class.new }
+
+  describe ".template_dir" do
+    context "when called without arguments" do
+      context "and the .template_dir has been perviously defined" do
+        let(:command_class) { TestGenerator::WithTemplateDir }
+
+        it "must set the previously set template_dir" do
+          expect(command_class.template_dir).to eq(File.join(__dir__,'fixtures','template'))
+        end
+      end
+
+      context "but the .template_dir has been defined in the superclass" do
+        let(:command_superclass) { TestGenerator::WithTemplateDir }
+        let(:command_class) { TestGenerator::InheritedTemplateDir }
+
+        it "must return the template_dir set in the superclass" do
+          expect(command_class.template_dir).to eq(command_superclass.template_dir)
+        end
+      end
+
+      context "but the template_dir has not been defined" do
+        let(:command_class) { TestGenerator::WithoutTemplateDir }
+
+        it "must return nil" do
+          expect(command_class.template_dir).to be(nil)
+        end
+      end
+    end
+
+    context "when called with a String" do
+      let(:command_class) { TestGenerator::WithTemplateDir }
+
+      it "must set the template_dir" do
+        expect(command_class.template_dir).to eq(File.join(__dir__,'fixtures','template'))
+      end
+    end
+  end
+
+  describe "#initialize" do
+    context "when the template_dir has been previously defined" do
+      it "must set #template_dir to the class'es .template_dir" do
+        expect(subject.template_dir).to eq(command_class.template_dir)
+      end
+    end
+
+    context "when the template_dir has not been previously defined" do
+      let(:command_class) { TestGenerator::WithoutTemplateDir }
+
+      it do
+        expect {
+          command_class.new
+        }.to raise_error(NotImplementedError,"#{command_class} did not define template_dir")
+      end
+    end
+  end
+
+  describe "#print_action" do
+    let(:stdout) { StringIO.new }
+
+    subject { command_class.new(stdout: stdout) }
+
+    context "when two arguments are given" do
+      let(:command) { 'touch' }
+      let(:dest)    { 'path/to/file' }
+
+      context "and STDOUT is a TTY" do
+        let(:ansi) { CommandKit::Colors::ANSI }
+
+        before do
+          allow(stdout).to receive(:tty?).and_return(true)
+        end
+
+        it "must output the command and dest highlighted in bold green" do
+          expect(stdout).to receive(:puts).with("\t#{ansi.bold(ansi.green(command))}\t#{ansi.green(dest)}")
+
+          subject.print_action(command,dest)
+        end
+      end
+
+      context "but STDOUT is not a TTY" do
+        it "must output the command and dest path separated by tabs" do
+          expect(stdout).to receive(:puts).with("\t#{command}\t#{dest}")
+
+          subject.print_action(command,dest)
+        end
+      end
+    end
+
+    context "when three arguments are given" do
+      let(:command) { 'cp -r' }
+      let(:source)  { 'dir' }
+      let(:dest)    { 'path/to/file' }
+
+      context "and STDOUT is a TTY" do
+        let(:ansi) { CommandKit::Colors::ANSI }
+
+        before do
+          allow(stdout).to receive(:tty?).and_return(true)
+        end
+
+        it "must output the command, source, and dest highlighted in bold green" do
+          expect(stdout).to receive(:puts).with("\t#{ansi.bold(ansi.green(command))}\t#{ansi.green(source)}\t#{ansi.green(dest)}")
+
+          subject.print_action(command,source,dest)
+        end
+      end
+
+      context "but STDOUT is not a TTY" do
+        it "must output the command, source, and dest path separated by tabs" do
+          expect(stdout).to receive(:puts).with("\t#{command}\t#{source}\t#{dest}")
+
+          subject.print_action(command,source,dest)
+        end
+      end
+    end
+  end
+
+  describe "#mkdir" do
+    let(:dest) { 'path/to/new_dir' }
+
+    it "must call #print_action and call FileUtils.mkdir_p" do
+      expect(subject).to receive(:print_action).with('mkdir',dest)
+      expect(FileUtils).to receive(:mkdir_p).with(dest)
+
+      subject.mkdir(dest)
+    end
+  end
+
+  describe "#touch" do
+    let(:dest) { 'path/to/new_file' }
+
+    it "must call #print_action and call FileUtils.touch" do
+      expect(subject).to receive(:print_action).with('touch',dest)
+      expect(FileUtils).to receive(:touch).with(dest)
+
+      subject.touch(dest)
+    end
+  end
+
+  describe "#chmod" do
+    let(:dest) { 'path/to/new_file' }
+    let(:mode) { "+x" }
+
+    it "must call #print_action and call FileUtils.chmod" do
+      expect(subject).to receive(:print_action).with("chmod",dest)
+      expect(FileUtils).to receive(:chmod).with(mode,dest)
+
+      subject.chmod(mode,dest)
+    end
+  end
+
+  describe "#cp" do
+    let(:source) { 'file.txt' }
+    let(:dest)   { 'path/to/root' }
+
+    it "must call #print_action and call FileUtils.cp" do
+      expect(subject).to receive(:print_action).with('cp',source,dest)
+      expect(FileUtils).to receive(:cp).with(
+        File.join(subject.template_dir,source), dest
+      )
+
+      subject.cp(source,dest)
+    end
+  end
+
+  describe "#cp_r" do
+    let(:source) { 'dir' }
+    let(:dest)   { 'path/to/root' }
+
+    it "must call #print_action and call FileUtils.cp_r" do
+      expect(subject).to receive(:print_action).with('cp -r',source,dest)
+      expect(FileUtils).to receive(:cp_r).with(
+        File.join(subject.template_dir,source), dest
+      )
+
+      subject.cp_r(source,dest)
+    end
+  end
+
+  describe "#erb" do
+    let(:source) { 'file.erb' }
+    let(:dest)   { 'path/to/new_file.txt' }
+
+    it "must call #print_action, render the ERB, and call File.write" do
+      expect(subject).to receive(:print_action).with('erb',source,dest)
+      expect(File).to receive(:write).with(
+        dest, "1 + 1 = 2"
+      )
+
+      subject.erb(source,dest)
+    end
+
+    context "when no destination path is given" do
+      it "must not call #print_action, but return the rendered result" do
+        expect(subject).to_not receive(:print_action).with('erb',source,dest)
+        expect(File).to_not receive(:write).with(
+          dest, "1 + 1 = 2"
+        )
+
+        expect(subject.erb(source)).to eq("1 + 1 = 2")
+      end
+    end
+  end
+
+  describe "#sh" do
+    let(:status) { double(:exit_status) }
+
+    let(:command) { 'cmd' }
+    let(:args)    { %w[-a -b foo] }
+
+    it "must call #print_action and run the command" do
+      expect(subject).to receive(:print_action).with(
+        'run', [command,*args].join(' ')
+      )
+
+      expect(subject).to receive(:system).with(command,*args).and_return(status)
+
+      expect(subject.sh(command,*args)).to be(status)
+    end
+  end
+end

data/spec/cli/logging_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+require 'ronin/core/cli/logging'
+require 'ronin/core/cli/command'
+require 'stringio'
+
+describe Ronin::Core::CLI::Logging do
+  module TestLogging
+    class TestCommand < Ronin::Core::CLI::Command
+
+      include Ronin::Core::CLI::Logging
+
+    end
+  end
+
+  let(:command_class) { TestLogging::TestCommand }
+  let(:stdout) { StringIO.new }
+  let(:stderr) { StringIO.new }
+  subject { command_class.new(stdout: stdout, stderr: stderr) }
+
+  let(:message) { "foo bar baz" }
+
+  let(:bright_green)  { CommandKit::Colors::ANSI::BRIGHT_GREEN  }
+  let(:bright_yellow) { CommandKit::Colors::ANSI::BRIGHT_YELLOW }
+  let(:bright_red)    { CommandKit::Colors::ANSI::BRIGHT_RED    }
+  let(:white)  { CommandKit::Colors::ANSI::WHITE  }
+  let(:bold)   { CommandKit::Colors::ANSI::BOLD   }
+  let(:reset_intensity) { CommandKit::Colors::ANSI::RESET_INTENSITY }
+  let(:reset_color)     { CommandKit::Colors::ANSI::RESET_COLOR     }
+
+  describe "#log_info" do
+    context "when stdout is a TTY" do
+      before { allow(stdout).to receive(:tty?).and_return(true) }
+
+      it "must print '>>> message' in bold-green and bold-white to stdout" do
+        subject.log_info(message)
+
+        expect(stdout.string).to eq(
+          "#{bold}#{bright_green}>>>#{reset_color}#{reset_intensity} #{bold}#{white}#{message}#{reset_color}#{reset_intensity}#{$/}"
+        )
+      end
+    end
+
+    context "when stdout is not a TTY" do
+      it "must print '>>> message' to stdout" do
+        subject.log_info(message)
+
+        expect(stdout.string).to eq(">>> #{message}#{$/}")
+      end
+    end
+  end
+
+  describe "#log_warn" do
+    context "when stdout is a TTY" do
+      before { allow(stdout).to receive(:tty?).and_return(true) }
+
+      it "must print '*** message' in bold-yellow and bold-white to stdout" do
+        subject.log_warn(message)
+
+        expect(stdout.string).to eq(
+          "#{bold}#{bright_yellow}***#{reset_color}#{reset_intensity} #{bold}#{white}#{message}#{reset_color}#{reset_intensity}#{$/}"
+        )
+      end
+    end
+
+    context "when stdout is not a TTY" do
+      it "must print '*** message' to stdout" do
+        subject.log_warn(message)
+
+        expect(stdout.string).to eq("*** #{message}#{$/}")
+      end
+    end
+  end
+
+  describe "#log_error" do
+    context "when stderr is a TTY" do
+      before { allow(stderr).to receive(:tty?).and_return(true) }
+
+      it "must print '!!! message' in bold-red and bold-white to stderr" do
+        subject.log_error(message)
+
+        expect(stderr.string).to eq(
+          "#{bold}#{bright_red}!!!#{reset_color}#{reset_intensity} #{bold}#{white}#{message}#{reset_color}#{reset_intensity}#{$/}"
+        )
+      end
+    end
+
+    context "when stdout is not a TTY" do
+      it "must print '!!! message' to stderr" do
+        subject.log_error(message)
+
+        expect(stderr.string).to eq("!!! #{message}#{$/}")
+      end
+    end
+  end
+end