ronin-support 0.5.1 → 1.0.0.beta1

data/spec/templates/erb_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-require 'ronin/templates/erb'
-
-require 'templates/classes/example_erb'
-
-describe Templates::Erb do
-  subject { ExampleErb.new }
-
-  before(:all) do
-    subject.x = 2
-    subject.y = 3
-  end
-
-  it "should render inline ERB templates" do
-    subject.erb(%{<%= 'hello' %>}).should == 'hello'
-  end
-
-  it "should render ERB templates using the binding of the object" do
-    subject.erb(%{<%= @x %> <%= @y %>}).should == '2 3'
-  end
-end

data/spec/templates/helpers/data/includes/_relative.erb

@@ -1 +0,0 @@
-This is a template that will be called using a relative path.

data/spec/templates/helpers/data/templates/example.erb

@@ -1 +0,0 @@
-Example template.

data/spec/templates/helpers/data.rb

@@ -1,9 +0,0 @@
-require 'data_paths'
-
-module Helpers
-  include DataPaths
-
-  TEMPLATE_DIR = File.expand_path(File.join(File.dirname(__FILE__),'data'))
-
-  register_data_path TEMPLATE_DIR
-end

data/spec/templates/template_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-require 'ronin/templates/template'
-
-require 'templates/classes/example_template'
-require 'templates/helpers/data'
-
-describe Templates::Template do
-  let(:example_template) { File.join(Helpers::TEMPLATE_DIR,'templates','example.erb') }
-  let(:relative_template) { File.join(Helpers::TEMPLATE_DIR,'includes','_relative.erb') }
-
-  subject { ExampleTemplate.new }
-
-  it "should return the result of the block when entering a template" do
-    subject.enter_example_template { |path|
-      'result'
-    }.should == 'result'
-  end
-
-  it "should be able to find templates relative to the current one" do
-    subject.enter_example_template do |path|
-      path.should == example_template
-    end
-  end
-
-  it "should be able to find static templates" do
-    subject.enter_relative_template do |path|
-      path.should == relative_template
-    end
-  end
-
-  it "should raise a RuntimeError when entering an unknown template" do
-    lambda {
-      subject.enter_missing_template { |path| }
-    }.should raise_error(RuntimeError)
-  end
-
-  it "should be able to read templates relative to the current one" do
-    subject.read_example_template do |contents|
-      contents.should == File.read(example_template)
-    end
-  end
-
-  it "should be able to find static templates" do
-    subject.read_relative_template do |contents|
-      contents.should == File.read(relative_template)
-    end
-  end
-
-  it "should raise a RuntimeError when entering an unknown template" do
-    lambda {
-      subject.read_missing_template { |path| }
-    }.should raise_error(RuntimeError)
-  end
-end

data/spec/ui/classes/test_shell.rb

@@ -1,22 +0,0 @@
-require 'ronin/ui/shell'
-
-class TestShell < Ronin::UI::Shell
-
-  def a_public_method
-  end
-
-  protected
-
-  def command1
-    :command1
-  end
-
-  def command_with_arg(arg)
-    arg
-  end
-
-  def command_with_args(*args)
-    args
-  end
-
-end

data/spec/ui/output_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-require 'ronin/ui/output'
-
-describe UI::Output do
-  it "should be quiet by default" do
-    should be_quiet
-  end
-
-  it "may become verbose" do
-    subject.verbose!
-
-    should be_verbose
-    should_not be_quiet
-    should_not be_silent
-  end
-
-  it "may become quiet" do
-    subject.quiet!
-
-    should be_quiet
-    should_not be_silent
-    should_not be_verbose
-  end
-
-  it "may become silent" do
-    subject.silent!
-
-    should be_silent
-    should_not be_quiet
-    should_not be_verbose
-  end
-end

data/spec/ui/shell_spec.rb

@@ -1,83 +0,0 @@
-require 'spec_helper'
-require 'ronin/ui/shell'
-
-require 'ui/classes/test_shell'
-
-describe UI::Shell do
-  context "with handler callback" do
-    let(:line) { 'one two three' }
-
-    it "should call the input handler with the shell and input line" do
-      lines = []
-      shell = described_class.new { |shell,input| lines << input }
-
-      shell.call(line)
-
-      lines.should == [line]
-    end
-  end
-
-  context "with commands" do
-    subject { TestShell.new }
-
-    describe "#commands" do
-      it "should include builtin methods" do
-        subject.commands.should include('help', 'exit')
-      end
-
-      it "should include protected methods" do
-        subject.commands.should include(
-          'command1',
-          'command_with_arg',
-          'command_with_args'
-        )
-      end
-
-      it "should not include public methods" do
-        subject.commands.should_not include('a_public_method')
-      end
-    end
-
-    describe "#call" do
-      it "should ignore empty lines" do
-        subject.call('').should == false
-      end
-
-      it "should ignore white-space lines" do
-        subject.call("     \t   ").should == false
-      end
-
-      it "should not allow calling the handler method" do
-        subject.call('handler').should == false
-      end
-
-      it "should not allow calling unknown commands" do
-        subject.call('an_unknown_command').should == false
-      end
-
-      it "should not allow calling unknown commands" do
-        subject.call('an_unknown_command').should == false
-      end
-
-      it "should not allow calling public methods" do
-        subject.call('a_public_method').should == false
-      end
-
-      it "should allow calling protected methods" do
-        subject.call('command1').should == :command1
-      end
-
-      it "should raise an exception when passing invalid number of arguments" do
-        lambda {
-          subject.call('command_with_arg too many args')
-        }.should raise_error(ArgumentError)
-      end
-
-      it "should splat the command arguments to the command method" do
-        subject.call('command_with_args one two three').should == [
-          'one', 'two', 'three'
-        ]
-      end
-    end
-  end
-end

data/spec/wordlist_spec.rb

@@ -1,151 +0,0 @@
-require 'spec_helper'
-require 'ronin/wordlist'
-
-require 'tmpdir'
-
-describe Wordlist do
-  let(:words) { %w[foo bar baz] }
-  let(:path)  { File.join(Dir.tmpdir,'ronin-support-wordlist') }
-
-  before(:all) do
-    File.open(path,'w') do |file|
-      file.puts(*words)
-    end
-  end
-
-  subject { described_class.new(words) }
-
-  describe "parse" do
-    subject { described_class }
-
-    let(:words) { ('aa'..'zz').to_a }
-    let(:text)  {
-      words.each_slice(100).map { |w| w.shuffle.join(' ') }.join("\n")
-    }
-
-    it "should parse unique words" do
-      subject.parse(text).to_a =~ words
-    end
-
-    it "should sort the unique words" do
-      subject.parse(text).to_a == words.sort
-    end
-
-    it "should yield unique words when they are seen" do
-      seen = []
-
-      subject.parse(text) { |word| seen << word }
-
-      seen.should =~ words
-    end
-  end
-
-  describe "create" do
-    let(:created_path) { File.join(Dir.tmpdir,'ronin-support-created-wordlist') }
-    let(:text) { words.join(' ') }
-
-    it "should return the new Wordlist object" do
-      wordlist = described_class.create(created_path,text)
-
-      wordlist.to_a.should =~ words
-    end
-
-    it "should create a wordlist file from text" do
-      described_class.create(created_path,text)
-
-      saved_words = File.open(created_path).each_line.map(&:chomp)
-
-      saved_words.should =~ words
-    end
-
-    it "should apply mutations to the created wordlist" do
-      described_class.create(created_path,text, 'o' => ['0'])
-
-      saved_words = File.open(created_path).each_line.map(&:chomp)
-
-      saved_words.should =~ %w[foo f0o fo0 f00 bar baz]
-    end
-
-    after(:all) { FileUtils.rm(created_path) }
-  end
-
-  describe "#initialize" do
-    it "should accept a list of words" do
-      wordlist = described_class.new(path)
-
-      wordlist.to_a.should == words
-    end
-
-    it "should accept a path to a wordlist file" do
-      wordlist = described_class.new(path)
-
-      wordlist.to_a.should == words
-    end
-
-    it "should raise a TypeError for non-String / non-Enumerable objects" do
-      lambda {
-        described_class.new(Object.new)
-      }.should raise_error(TypeError)
-    end
-  end
-
-  describe "#each_word" do
-    context "with wordlist file" do
-      subject { described_class.new(path) }
-
-      it "should enumerate over the words" do
-        subject.each_word.to_a.should == words
-      end
-    end
-
-    context "with words" do
-      subject { described_class.new(words) }
-
-      it "should enumerate over the words" do
-        subject.each_word.to_a.should == words
-      end
-    end
-  end
-
-  describe "#each" do
-    it "should rewind file lists" do
-      subject.each { |word| }
-
-      subject.to_a.should == words
-    end
-
-    it "should apply additional mutation rules" do
-      wordlist = described_class.new(words)
-      wordlist.mutations['o'] = ['0']
-
-      wordlist.to_a.should =~ %w[foo f0o fo0 f00 bar baz]
-    end
-  end
-
-  describe "#each_n_words" do
-    it "should enumerate over every combination of N words" do
-      subject.each_n_words(2).to_a.should == %w[
-        foofoo foobar foobaz
-        barfoo barbar barbaz
-        bazfoo bazbar bazbaz
-      ]
-    end
-  end
-
-  describe "#save" do
-    let(:saved_path) { File.join(Dir.tmpdir,'ronin-support-saved-wordlist') }
-
-    it "should save the words with mutations to a file" do
-      subject.save(saved_path)
-
-      saved_words    = File.open(saved_path).each_line.map(&:chomp)
-      expected_words = subject.to_a
-
-      saved_words.should == expected_words
-    end
-
-    after(:all) { FileUtils.rm(saved_path) }
-  end
-
-  after(:all) { FileUtils.rm(path) }
-end