ronin-web 0.3.0.rc1 → 1.0.0.beta2

data/ronin-web.gemspec

@@ -2,130 +2,60 @@
 
 require 'yaml'
 
-Gem::Specification.new do |gemspec|
-  root = File.dirname(__FILE__)
-  lib_dir = File.join(root,'lib')
-  files = if File.directory?('.git')
-            `git ls-files`.split($/)
-          elsif File.directory?('.hg')
-            `hg manifest`.split($/)
-          elsif File.directory?('.svn')
-            `svn ls -R`.split($/).select { |path| File.file?(path) }
-          else
-            Dir['{**/}{.*,*}'].select { |path| File.file?(path) }
-          end
+Gem::Specification.new do |gem|
+  gemspec = YAML.load_file('gemspec.yml')
 
-  filter_files = lambda { |paths|
-    case paths
-    when Array
-      (files & paths)
-    when String
-      (files & Dir[paths])
-    end
-  }
-
-  version = {
-    :file => 'ronin/web/version',
-    :constant => 'Ronin::Web::VERSION'
-  }
-
-  defaults = {
-    'name' => File.basename(root),
-    'files' => files,
-    'executables' => filter_files['bin/*'].map { |path| File.basename(path) },
-    'test_files' => filter_files['{test/{**/}*_test.rb,spec/{**/}*_spec.rb}'],
-    'extra_doc_files' => filter_files['*.{txt,rdoc,md,markdown,tt,textile}'],
-  }
+  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)
 
-  metadata = defaults.merge(YAML.load_file('gemspec.yml'))
+                  require 'ronin/web/version'
+                  Ronin::Web::VERSION
+                end
 
-  gemspec.name = metadata.fetch('name',defaults[:name])
-  gemspec.version = if metadata['version']
-                      metadata['version']
-                    else
-                      $LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
+  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']
 
-                      require version[:file]
-                      eval(version[:constant])
-                    end
+  glob = lambda { |patterns| gem.files & Dir[*patterns] }
 
-  gemspec.summary = metadata.fetch('summary',metadata['description'])
-  gemspec.description = metadata.fetch('description',metadata['summary'])
+  gem.files = `git ls-files`.split($/)
+  gem.files = glob[gemspec['files']] if gemspec['files']
+  gem.files += Array(gemspec['generated_files'])
 
-  case metadata['license']
-  when Array
-    gemspec.licenses = metadata['license']
-  when String
-    gemspec.license = metadata['license']
+  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.'
 
-  case metadata['authors']
-  when Array
-    gemspec.authors = metadata['authors']
-  when String
-    gemspec.author = metadata['authors']
-  end
-
-  gemspec.email = metadata['email']
-  gemspec.homepage = metadata['homepage']
+  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}']
 
-  case metadata['require_paths']
-  when Array
-    gemspec.require_paths = metadata['require_paths']
-  when String
-    gemspec.require_path = metadata['require_paths']
-  end
+  gem.require_paths = Array(gemspec.fetch('require_paths') {
+    %w[ext lib].select { |dir| File.directory?(dir) }
+  })
 
-  gemspec.files = filter_files[metadata['files']]
+  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']
 
-  gemspec.executables = metadata['executables']
-  gemspec.extensions = metadata['extensions']
-
-  if Gem::VERSION < '1.7.'
-    gemspec.default_executable = gemspec.executables.first
-  end
-
-  gemspec.test_files = filter_files[metadata['test_files']]
-
-  unless gemspec.files.include?('.document')
-    gemspec.extra_rdoc_files = metadata['extra_doc_files']
-  end
-
-  gemspec.post_install_message = metadata['post_install_message']
-  gemspec.requirements = metadata['requirements']
-
-  if gemspec.respond_to?(:required_ruby_version=)
-    gemspec.required_ruby_version = metadata['required_ruby_version']
-  end
-
-  if gemspec.respond_to?(:required_rubygems_version=)
-    gemspec.required_rubygems_version = metadata['required_ruby_version']
-  end
-
-  parse_versions = lambda { |versions|
-    case versions
-    when Array
-      versions.map { |v| v.to_s }
-    when String
-      versions.split(/,\s*/)
-    end
-  }
-
-  if metadata['dependencies']
-    metadata['dependencies'].each do |name,versions|
-      gemspec.add_dependency(name,parse_versions[versions])  
-    end
-  end
+  split = lambda { |string| string.split(/,\s*/) }
 
-  if metadata['runtime_dependencies']
-    metadata['runtime_dependencies'].each do |name,versions|
-      gemspec.add_runtime_dependency(name,parse_versions[versions])  
+  if gemspec['dependencies']
+    gemspec['dependencies'].each do |name,versions|
+      gem.add_dependency(name,split[versions])
     end
   end
 
-  if metadata['development_dependencies']
-    metadata['development_dependencies'].each do |name,versions|
-      gemspec.add_development_dependency(name,parse_versions[versions])  
+  if gemspec['development_dependencies']
+    gemspec['development_dependencies'].each do |name,versions|
+      gem.add_development_dependency(name,split[versions])
     end
   end
 end

data/spec/cli/ruby_shell_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require 'ronin/web/cli/ruby_shell'
+
+describe Ronin::Web::CLI::RubyShell do
+  describe "#initialize" do
+    it "must default #name to 'ronin-web'" do
+      expect(subject.name).to eq('ronin-web')
+    end
+
+    it "must default #context to Ronin::Web" do
+      expect(subject.context).to be(Ronin::Web)
+    end
+  end
+end

data/spec/html_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'ronin/web/html'
+
+describe Ronin::Web::HTML do
+  describe ".parse" do
+    let(:html) do
+      <<~HTML
+      <html>
+        <body>Hello</body>
+      </html>
+      HTML
+    end
+
+    it "must parse an HTML String and return a Nokogiri::HTML::Document" do
+      doc = subject.parse(html)
+
+      expect(doc).to be_kind_of(Nokogiri::HTML::Document)
+      expect(doc.at('body').inner_text).to eq("Hello")
+    end
+
+    context "when given a block" do
+      it "must yield the Nokogiri::HTML::Document object" do
+        expect { |b|
+          subject.parse(html,&b)
+        }.to yield_with_args(Nokogiri::HTML::Document)
+      end
+    end
+  end
+
+  describe ".build" do
+    it "must build an HTML document" do
+      doc = subject.build do
+        html {
+          body {
+            div { text("hello") }
+          }
+        }
+      end
+
+      expect(doc.to_html).to include("<html><body><div>hello</div></body></html>")
+    end
+  end
+end

data/spec/mechanize_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'ronin/web/mechanize'
+
+describe Ronin::Web::Mechanize do
+  describe "#initialize" do
+    context "when Ronin::Support::Network::HTTP.user_agent is set" do
+      let(:user_agent) { 'test' }
+
+      before { Ronin::Support::Network::HTTP.user_agent = user_agent }
+
+      it "should set #user_agent to Ronin::Support::Network::HTTP.user_agent" do
+        expect(subject.user_agent).to eq(user_agent)
+      end
+
+      after { Ronin::Support::Network::HTTP.user_agent = nil }
+    end
+
+    context "when the :user_agent option is given" do
+      context "and it's a String" do
+        let(:user_agent) { 'test2' }
+
+        subject { described_class.new(user_agent: user_agent) }
+
+        it "should set #user_agent to the custom User-Agent string" do
+          expect(subject.user_agent).to eq(user_agent)
+        end
+      end
+
+      context "and it's a Symbol" do
+        let(:user_agent) { :chrome_linux }
+        let(:expected_user_agent) do
+          Ronin::Support::Network::HTTP::UserAgents[user_agent]
+        end
+
+        subject { described_class.new(user_agent: user_agent) }
+
+        it "should set #user_agent to the custom User-Agent alias" do
+          expect(subject.user_agent).to eq(expected_user_agent)
+        end
+      end
+    end
+
+    let(:host)  { '127.0.0.1' }
+    let(:port)  { 8080 }
+    let(:proxy) { URI::HTTP.build(host: host, port: port) }
+
+    context "when Ronin::Support::Network::HTTP.proxy is set" do
+      before { Ronin::Support::Network::HTTP.proxy = proxy }
+
+      it "should set #proxy_addr and #proxy_port to Ronin::Support::Network::HTTP.proxy" do
+        expect(subject.proxy_addr).to eq(
+          Ronin::Support::Network::HTTP.proxy.host
+        )
+
+        expect(subject.proxy_port).to eq(
+          Ronin::Support::Network::HTTP.proxy.port
+        )
+      end
+
+      after { Ronin::Support::Network::HTTP.proxy = nil }
+    end
+
+    context "when the :proxy option is given" do
+      subject { described_class.new(proxy: proxy) }
+
+      it "should set #proxy_addr and #proxy_port to the custom proxy" do
+        expect(subject.proxy_addr).to eq(host)
+        expect(subject.proxy_port).to eq(port)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,8 @@
 require 'rspec'
-require 'ronin/spec/database'
+require 'simplecov'
 
-require 'ronin/web/version'
+SimpleCov.start
 
-include Ronin
+RSpec.configure do |specs|
+  specs.filter_run_excluding :network
+end

data/spec/web_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+require 'ronin/web'
+
+describe Ronin::Web do
+  let(:url) { 'https://example.com/' }
+
+  it "should have a VERSION constant" do
+    expect(subject.const_defined?('VERSION')).to eq(true)
+  end
+
+  describe ".html" do
+    it "should be able to parse HTML" do
+      doc = subject.html(%{
+        <html>
+          <body>Hello</body>
+        </html>
+      })
+
+      expect(doc.at('body').inner_text).to eq("Hello")
+    end
+  end
+
+  describe ".build_html" do
+    it "should be able to build HTML documents" do
+      doc = subject.build_html do
+        html {
+          body {
+            div { text("hello") }
+          }
+        }
+      end
+
+      expect(doc.to_html).to include("<html><body><div>hello</div></body></html>")
+    end
+  end
+
+  describe ".xml" do
+    it "should be able to parse XML" do
+      doc = subject.xml(%{
+        <?xml version="1.0"?>
+        <root>
+          <stuff>Hello</stuff>
+        </root>
+      })
+
+      expect(doc.at('stuff').inner_text).to eq("Hello")
+    end
+  end
+
+  describe ".build_xml" do
+    it "should be able to build XML documents" do
+      doc = subject.build_xml do
+        root {
+          stuff(name: 'bla') { text("hello") }
+        }
+      end
+
+      expect(doc.to_xml).to include("<root>\n  <stuff name=\"bla\">hello</stuff>\n</root>")
+    end
+  end
+
+  describe ".open", :network do
+    it "must open URLs as temporary files" do
+      file = subject.open(url)
+
+      expect(file).to be_kind_of(StringIO)
+      expect(file.read).to include("Example Domain")
+    end
+  end
+
+  describe ".agent" do
+    it "must return a #{described_class}::Mechanize object" do
+      expect(subject.agent).to be_kind_of(described_class::Mechanize)
+    end
+
+    it "must return the same object each time" do
+      expect(subject.agent).to be(subject.agent)
+    end
+  end
+
+  describe ".get", :network do
+    it "should be able to get Mechanize pages" do
+      page = subject.get(url)
+
+      expect(page.class).to eq(Mechanize::Page)
+      expect(page.uri).to eq(URI(url))
+    end
+  end
+
+  describe ".get_body", :network do
+    it "should be able to get the bodies of Mechanize pages" do
+      body = subject.get_body(url)
+
+      expect(body).to include("Example Domain")
+    end
+  end
+end

data/spec/xml_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'ronin/web/xml'
+
+describe Ronin::Web::XML do
+  describe ".parse" do
+    let(:xml) do
+      <<~XML
+      <?xml version="1.0"?>
+      <root>
+        <stuff>Hello</stuff>
+      </root>
+      XML
+    end
+
+    it "must parse an XML String and return a Nokogiri::XML::Document" do
+      doc = subject.parse(xml)
+
+      expect(doc).to be_kind_of(Nokogiri::XML::Document)
+      expect(doc.at('stuff').inner_text).to eq("Hello")
+    end
+
+    context "when given a block" do
+      it "must yield the Nokogiri::XML::Document object" do
+        expect { |b|
+          subject.parse(xml,&b)
+        }.to yield_with_args(Nokogiri::XML::Document)
+      end
+    end
+  end
+
+  describe ".build" do
+    it "must build an XML document" do
+      doc = subject.build do
+        root {
+          stuff(name: 'bla') { text("hello") }
+        }
+      end
+
+      expect(doc.to_xml).to include("<root>\n  <stuff name=\"bla\">hello</stuff>\n</root>")
+    end
+  end
+end