ronin 0.2.1 → 0.2.2

data/lib/ronin/ui/command_line/commands/overlay.rb

@@ -1,189 +0,0 @@
-#
-#--
-# Ronin - A Ruby platform designed for information security and data
-# exploration tasks.
-#
-# Copyright (c) 2006-2009 Hal Brodigan (postmodern.mod3 at gmail.com)
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-#++
-#
-
-require 'ronin/ui/command_line/command'
-require 'ronin/platform/overlay'
-require 'ronin/version'
-
-require 'fileutils'
-require 'nokogiri'
-
-module Ronin
-  module UI
-    module CommandLine
-      module Commands
-        class Overlay < Command
-
-          include Nokogiri
-
-          def defaults
-            @title = nil
-            @source = nil
-            @source_view = nil
-            @website = nil
-            @license = nil
-            @maintainers = []
-            @description = nil
-          end
-
-          def define_options(opts)
-            opts.usage = '[options] PATH'
-
-            opts.options do
-              opts.on('-t','--title NAME','Name of the Overlay') do |title|
-                @title = title
-              end
-
-              opts.on('-S','--source URL','The URL where the source of the Overlay will be hosted') do |url|
-                @source = url
-              end
-
-              opts.on('-V','--source-view URL','The URL for viewing the contents of the Overlay') do |url|
-                @source_view = url
-              end
-
-              opts.on('-U','--website URL','The URL of the website of the Overlay') do |url|
-                @website = url
-              end
-
-              opts.on('-L','--license LICENSE','The license of the contents of the Overlay') do |license|
-                @license = license
-              end
-
-              opts.on('-m','--maintainer "NAME <EMAIL>"','Name of a maintainer of the Overlay') do |text|
-                name = text.scan(/^[^<]+[^<\s]/).first
-                email = text.scan(/<([^<>]+)>\s*$/).first
-
-                email = email.first if email
-
-                @maintainers << {:name => name, :email => email}
-              end
-
-              opts.on('-D','--description TEXT','The description for the Overlay') do |text|
-                @description = text
-              end
-            end
-
-            opts.arguments(
-              'PATH' => 'The PATH of the Overlay to be created'
-            )
-
-            opts.summary('Create an empty Overlay at the specified PATH')
-          end
-
-          def arguments(*args)
-            unless args.length == 1
-              fail('only one Overlay path maybe specified')
-            end
-
-            path = File.expand_path(args.first)
-
-            @title ||= File.basename(path).gsub(/[_\s]+/,' ').capitalize
-            @source_view ||= @source
-            @website ||= @source_view
-
-            FileUtils.mkdir_p(path)
-            FileUtils.mkdir_p(File.join(path,'lib'))
-            FileUtils.mkdir_p(File.join(path,'objects'))
-
-            File.open(File.join(path,Platform::Overlay::METADATA_FILE),'w') do |file|
-              doc = XML::Document.new
-              doc << XML::ProcessingInstruction.new(
-                doc,
-                'xml-stylesheet',
-                'type="text/xsl" href="http://ronin.rubyforge.org/dist/overlay.xsl"'
-              )
-
-              root = XML::Node.new('ronin-overlay',doc)
-              root['version'] = Ronin::VERSION
-
-              title_tag = XML::Node.new('title',doc)
-              title_tag << XML::Text.new(@title,doc)
-              root << title_tag
-
-              if @source
-                source_tag = XML::Node.new('source',doc)
-                source_tag << XML::Text.new(@source,doc)
-                root << source_tag
-              end
-
-              if @source_view
-                source_view_tag = XML::Node.new('source-view',doc)
-                source_view_tag << XML::Text.new(@source_view,doc)
-                root << source_view_tag
-              end
-
-              if @website
-                url_tag = XML::Node.new('website',doc)
-                url_tag << XML::Text.new(@website,doc)
-                root << url_tag
-              end
-
-              if @license
-                license_tag = XML::Node.new('license',doc)
-                license_tag << XML::Text.new(@license,doc)
-                root << license_tag
-              end
-
-              unless @maintainers.empty?
-                maintainers_tag = XML::Node.new('maintainers',doc)
-
-                @maintainers.each do |author|
-                  if (author[:name] || author[:email])
-                    maintainer_tag = XML::Node.new('maintainer',doc)
-
-                    if author[:name]
-                      name_tag = XML::Node.new('name',doc)
-                      name_tag << XML::Text.new(author[:name],doc)
-                      maintainer_tag << name_tag
-                    end
-
-                    if author[:email]
-                      email_tag = XML::Node.new('email',doc)
-                      email_tag << XML::Text.new(author[:email],doc)
-                      maintainer_tag << email_tag
-                    end
-
-                    maintainers_tag << maintainer_tag
-                  end
-                end
-
-                root << maintainers_tag
-              end
-
-              if @description
-                description_tag = XML::Node.new('description',doc)
-                description_tag << XML::Text.new(@description,doc)
-                root << description_tag
-              end
-
-              doc << root
-              doc.write_xml_to(file)
-            end
-          end
-
-        end
-      end
-    end
-  end
-end

data/spec/chars/char_set_spec.rb

@@ -1,175 +0,0 @@
-require 'ronin/chars/chars'
-
-require 'spec_helper'
-
-describe Chars::CharSet do
-  before(:all) do
-    @integer_range = (0x41..0x43)
-    @string_range = ('A'..'C')
-    @integers = @integer_range.to_a
-    @strings = @string_range.to_a
-
-    @char_set = Chars::CharSet.new(*@strings)
-  end
-
-  it "may be created with String arguments" do
-    @chars = Chars::CharSet.new(*@strings)
-
-    @strings.each do |s|
-      @chars.include_char?(s).should == true
-    end
-  end
-
-  it "may be created with an Array of Strings" do
-    @chars = Chars::CharSet.new(@strings)
-
-    @strings.each do |s|
-      @chars.include_char?(s).should == true
-    end
-  end
-
-  it "may be created with a Range of Strings" do
-    @chars = Chars::CharSet.new(@string_range)
-
-    @strings.each do |s|
-      @chars.include_char?(s).should == true
-    end
-  end
-
-  it "may be created with Integer arguments" do
-    @chars = Chars::CharSet.new(*@integers)
-
-    @integers.each do |i|
-      @chars.include?(i).should == true
-    end
-  end
-
-  it "may be created with an Array of Integers" do
-    @chars = Chars::CharSet.new(@integers)
-
-    @integers.each do |i|
-      @chars.include?(i).should == true
-    end
-  end
-
-  it "may be created with a Range of Integers" do
-    @chars = Chars::CharSet.new(@integer_range)
-
-    @integers.each do |i|
-      @chars.include?(i).should == true
-    end
-  end
-
-  it "should include Strings" do
-    @char_set.include_char?('A').should == true
-  end
-
-  it "should include Integers" do
-    @char_set.include?(0x41).should == true
-  end
-
-  it "should be able to select bytes" do
-    @sub_chars = @char_set.select_bytes { |c| c <= 0x42 }
-
-    @sub_chars.should == [0x41, 0x42]
-  end
-
-  it "should be able to select chars" do
-    @sub_chars = @char_set.select_chars { |c| c <= 'B' }
-
-    @sub_chars.should == ['A', 'B']
-  end
-
-  it "should return a random byte" do
-    @char_set.include?(@char_set.random_byte).should == true
-  end
-
-  it "should return a random char" do
-    @char_set.include_char?(@char_set.random_char).should == true
-  end
-
-  it "should iterate over n random bytes" do
-    @char_set.each_random_byte(10) do |b|
-      @char_set.include?(b).should == true
-    end
-  end
-
-  it "should iterate over n random chars" do
-    @char_set.each_random_char(10) do |c|
-      @char_set.include_char?(c).should == true
-    end
-  end
-
-  it "should return a random Array of bytes" do
-    bytes = @char_set.random_bytes(10)
-
-    bytes.each do |b|
-      @char_set.include?(b).should == true
-    end
-  end
-
-  it "should return a random Array of chars" do
-    chars = @char_set.random_chars(10)
-
-    chars.each do |c|
-      @char_set.include_char?(c).should == true
-    end
-  end
-
-  it "should return a random Array of bytes with a varying length" do
-    bytes = @char_set.random_bytes(5..10)
-
-    bytes.length.between?(5, 10).should == true
-    bytes.each do |b|
-      @char_set.include?(b).should == true
-    end
-  end
-
-  it "should return a random Array of chars with a varying length" do
-    chars = @char_set.random_chars(5..10)
-
-    chars.length.between?(5, 10).should == true
-    chars.each do |c|
-      @char_set.include_char?(c).should == true
-    end
-  end
-
-  it "should return a random String of chars" do
-    @char_set.random_string(10).each_byte do |b|
-      @char_set.include?(b).should == true
-    end
-  end
-
-  it "should return a random String of chars with a varying length" do
-    string = @char_set.random_string(5..10)
-
-    string.length.between?(5, 10)
-    string.each_byte do |b|
-      @char_set.include?(b).should == true
-    end
-  end
-
-  it "should be able to be compared with another set of chars" do
-    (@char_set == Chars::CharSet['A', 'B', 'C']).should == true
-    (@char_set == Chars::CharSet['A', 'C', 'B']).should == true
-  end
-
-  it "should be able to be unioned with another set of chars" do
-    super_set = (@char_set | Chars::CharSet['D'])
-
-    super_set.class.should == Chars::CharSet
-    super_set.should == Chars::CharSet['A', 'B', 'C', 'D']
-  end
-
-  it "should be able to be removed from another set of chars" do
-    sub_set = (@char_set - Chars::CharSet['B'])
-
-    sub_set.class.should == Chars::CharSet
-    sub_set.subset?(@char_set).should == true
-  end
-
-  it "should determine if a String is made up of the characters from the char set" do
-    (@char_set =~ "AABCBAA").should == true
-    (@char_set =~ "AADDEE").should_not == true
-  end
-end

data/spec/chars/chars_spec.rb

@@ -1,107 +0,0 @@
-require 'ronin/chars/chars'
-
-require 'spec_helper'
-
-describe Chars do
-  before(:all) do
-    @numeric_string = Chars.numeric.random_string(10)
-    @octal_string = Chars.octal.random_string(10)
-    @uppercase_hex_string = Chars.uppercase_hexadecimal.random_string(10)
-    @lowercase_hex_string = Chars.lowercase_hexadecimal.random_string(10)
-    @hex_string = Chars.hexadecimal.random_string(10)
-    @uppercase_alpha_string = Chars.uppercase_alpha.random_string(10)
-    @lowercase_alpha_string = Chars.lowercase_alpha.random_string(10)
-    @alpha_string = Chars.alpha.random_string(10)
-    @alpha_numeric_string = Chars.alpha_numeric.random_string(10)
-    @space_string = Chars.space.random_string(10)
-    @punctuation_string = Chars.punctuation.random_string(10)
-    @symbols_string = Chars.symbols.random_string(10)
-    @control_string = Chars.control.random_string(10)
-    @ascii_string = Chars.ascii.random_string(10)
-    @all_string = Chars.all.random_string(10)
-  end
-
-  it "should provide a numeric CharSet" do
-    @numeric_string.length.should == 10
-    @numeric_string.each_byte do |b|
-      Chars::NUMERIC.include?(b).should == true
-    end
-  end
-
-  it "should provide an octal CharSet" do
-    @octal_string.length.should == 10
-    @octal_string.each_byte do |b|
-      Chars::OCTAL.include?(b).should == true
-    end
-  end
-
-  it "should provide an upper-case hexadecimal CharSet" do
-    @uppercase_hex_string.length.should == 10
-    @uppercase_hex_string.each_byte do |b|
-      Chars::UPPERCASE_HEXADECIMAL.include?(b).should == true
-    end
-  end
-
-  it "should provide a lower-case hexadecimal CharSet" do
-    @lowercase_hex_string.length.should == 10
-    @lowercase_hex_string.each_byte do |b|
-      Chars::LOWERCASE_HEXADECIMAL.include?(b).should == true
-    end
-  end
-
-  it "should provide a hexadecimal CharSet" do
-    @hex_string.length.should == 10
-    @hex_string.each_byte do |b|
-      Chars::HEXADECIMAL.include?(b).should == true
-    end
-  end
-
-  it "should provide an upper-case alpha CharSet" do
-    @uppercase_alpha_string.length.should == 10
-    @uppercase_alpha_string.each_byte do |b|
-      Chars::UPPERCASE_ALPHA.include?(b).should == true
-    end
-  end
-
-  it "should provide a lower-case alpha CharSet" do
-    @lowercase_alpha_string.length.should == 10
-    @lowercase_alpha_string.each_byte do |b|
-      Chars::LOWERCASE_ALPHA.include?(b).should == true
-    end
-  end
-
-  it "should provide an alpha CharSet" do
-    @alpha_string.length.should == 10
-    @alpha_string.each_byte do |b|
-      Chars::ALPHA.include?(b).should == true
-    end
-  end
-
-  it "should provide an alpha-numeric CharSet" do
-    @alpha_numeric_string.length.should == 10
-    @alpha_numeric_string.each_byte do |b|
-      Chars::ALPHA_NUMERIC.include?(b).should == true
-    end
-  end
-
-  it "should provide a space CharSet" do
-    @space_string.length.should == 10
-    @space_string.each_byte do |b|
-      Chars::SPACE.include?(b).should == true
-    end
-  end
-
-  it "should provide a punctuation CharSet" do
-    @punctuation_string.length.should == 10
-    @punctuation_string.each_byte do |b|
-      Chars::PUNCTUATION.include?(b).should == true
-    end
-  end
-
-  it "should provide a symbols CharSet" do
-    @symbols_string.length.should == 10
-    @symbols_string.each_byte do |b|
-      Chars::SYMBOLS.include?(b).should == true
-    end
-  end
-end