swamp 1.1.2 → 1.2.0

data/lib/swamp/setup.rb

@@ -0,0 +1,49 @@
+module Swamp
+  class Setup
+    attr_reader :scope
+
+    COMMAND_LIST = {
+      ":scope" => ["source", "page"]
+    }
+
+    include Swamp::Assertions
+
+    def initialize
+      @scope = "page"
+    end
+
+    def handle_command(input)
+      @input = input
+      remove_white_spaces
+
+      begin
+        assert { COMMAND_LIST[command] && COMMAND_LIST[command].include?(value) }
+      rescue ArgumentError
+        return ["Invalid command"]
+      end
+
+      @scope = value
+
+      [success_message]
+    end
+
+    private
+
+    def success_message
+      ["Option", " ",  command, " ", "set", " ", "to", " ", value].join
+    end
+
+    def command
+      @input.split("=")[0]
+    end
+
+    def value
+      @input.split("=")[1]
+    end
+
+    def remove_white_spaces
+      @input = @input.gsub(/\s+/, "")
+    end
+
+  end
+end

data/lib/swamp/version.rb

@@ -1,3 +1,3 @@
 module Swamp
-  VERSION = '1.1.2'
+  VERSION = '1.2.0'
 end

data/lib/swamp/wrapper.rb

@@ -1,12 +1,13 @@
 module Swamp
   class Wrapper < Base
-    def initialize(meta_collection)
+    attr_reader :page_visited
+
+    def initialize(meta_collection, setup)
       @meta_collection = meta_collection
       @page_visited = false
+      @setup = setup
     end
 
-    attr_reader :page_visited
-
     def explore(url)
       if !page_visited
         visit url
@@ -17,7 +18,7 @@ module Swamp
     def scan
       found_snippets = []
       @meta_collection.each do | element_collection |
-        found_snippets += element_collection.get.map { | element | Swamp::Builder.new(element).build_snippet }
+        found_snippets += element_collection.get.map { | element | Swamp::Builder.new(element, @setup).build_snippet }
       end
       found_snippets
     end

data/spec/spec_helper.rb

@@ -2,7 +2,7 @@ require 'swamp'
 
 RSpec.configure do |config|
   # Use color in STDOUT
-  config.color_enabled = true
+  config.color = true
 
   # Use color not only in STDOUT but also in pagers and files
   #config.tty = true

data/spec/swamp/builder_spec.rb

@@ -1,35 +1,45 @@
 require 'spec_helper'
 module Swamp
   describe Builder do
+    let(:setup) { setup = Swamp::Setup.new }
+
     describe "#build_method" do
       context "when the type is field" do
-        let(:type) { :field }
         context "when the name and the selector are present" do
           it "returns the method's snippet" do
             element = Swamp::Field.new("User-Name", "User-Name")
-            builder = Swamp::Builder.new(element)
-            builder.build_snippet.should == "def type_user_name(input)\n  source.fill_in(\"User-Name\", with: input)\nend"
+            builder = Swamp::Builder.new(element, setup)
+            expect(builder.build_snippet).to eq("def type_user_name(input)\n  page.fill_in(\"User-Name\", with: input)\nend")
           end
         end
       end
 
       context "when the type is button" do
-        let(:type) { :button }
         context "when the name and the selector are present" do
           it "returns the method's snippet" do
             element = Swamp::Button.new("Log_in", "Log_in")
-            builder = Swamp::Builder.new(element)
-            builder.build_snippet.should == "def log_in\n  source.click_button(\"Log_in\")\nend"
+            builder = Swamp::Builder.new(element, setup)
+            expect(builder.build_snippet).to eq("def log_in\n  page.click_button(\"Log_in\")\nend")
           end
         end
 
         context "when just the selector is present" do
           it "returns just the selector snippet" do
             element = Swamp::Button.new(nil, "$ 9.90 Buy")
-            builder = Swamp::Builder.new(element)
-            builder.build_snippet.should == "source.click_button(\"$ 9.90 Buy\")"
+            builder = Swamp::Builder.new(element, setup)
+            expect(builder.build_snippet).to eq("page.click_button(\"$ 9.90 Buy\")")
+          end
+        end
+
+        context "when the scope has changed" do
+          it "returns the method's snippet with the changed scope" do
+            element = Swamp::Button.new("Log_in", "Log_in")
+            allow(setup).to receive(:scope).and_return("source")
+            builder = Swamp::Builder.new(element, setup)
+            expect(builder.build_snippet).to eq("def log_in\n  source.click_button(\"Log_in\")\nend")
           end
         end
+
       end
     end
   end

data/spec/swamp/buttons_spec.rb

@@ -5,10 +5,10 @@ module Swamp
 
     it "delegates to capybara the responsibility to get the buttons" do
       element = {'id' => "u_0_2"}
-      element.stub(:text).and_return("Sign Up")
-      element.stub(:visible?).and_return(true)
-      buttons.page.stub(:execute_script).and_return(nil)
-      buttons.page.should_receive(:all).with('button').and_return([element])
+      allow(element).to receive(:text).and_return("Sign Up")
+      allow(element).to receive(:visible?).and_return(true)
+      allow(buttons.page).to receive(:execute_script).and_return(nil)
+      expect(buttons.page).to receive(:all).with('button').and_return([element])
       buttons.get
     end
 
@@ -17,21 +17,21 @@ module Swamp
         let(:element) { {'id' => "u_0_2"} }
 
         before(:each) do
-          element.stub(:visible?).and_return(true)
-          element.stub(:text).and_return("Sign Up")
-          buttons.page.stub(:all).with('button').and_return([element])
+          allow(element).to receive(:visible?).and_return(true)
+          allow(element).to receive(:text).and_return("Sign Up")
+          allow(buttons.page).to receive(:all).with('button').and_return([element])
         end
 
         it "highlights the element" do
-          buttons.page.should_receive(:execute_script).twice
+          expect(buttons.page).to receive(:execute_script).twice
           buttons.get
         end
 
         it "returns the element in the array using the text as both the name and the selector" do
-          buttons.page.stub(:execute_script).and_return(nil)
-          buttons.get.should have(1).button
-          buttons.get.each.first.name.should == "Sign Up"
-          buttons.get.each.first.selector.should == "Sign Up"
+          allow(buttons.page).to receive(:execute_script).and_return(nil)
+          expect(buttons.get.size).to eq(1)
+          expect(buttons.get.each.first.name).to eq("Sign Up")
+          expect(buttons.get.each.first.selector).to eq("Sign Up")
         end
       end
 
@@ -40,21 +40,21 @@ module Swamp
           let(:element) { {'id' => "search-button"} }
 
           before(:each) do
-            element.stub(:visible?).and_return(true)
-            element.stub(:text).and_return("")
-            buttons.page.stub(:all).with('button').and_return([element])
+            allow(element).to receive(:visible?).and_return(true)
+            allow(element).to receive(:text).and_return("")
+            allow(buttons.page).to receive(:all).with('button').and_return([element])
           end
 
           it "highlights the element" do
-            buttons.page.should_receive(:execute_script).twice
+            expect(buttons.page).to receive(:execute_script).twice
             buttons.get
           end
 
           it "returns the element in the array using the id as both the name and the selector" do
-            buttons.page.stub(:execute_script).and_return(nil)
-            buttons.get.should have(1).button
-            buttons.get.each.first.name.should == "search-button"
-            buttons.get.each.first.selector.should == "search-button"
+            allow(buttons.page).to receive(:execute_script).and_return(nil)
+            expect(buttons.get.size).to eq(1)
+            expect(buttons.get.each.first.name).to eq("search-button")
+            expect(buttons.get.each.first.selector).to eq("search-button")
           end
         end
 
@@ -63,21 +63,21 @@ module Swamp
             let(:element) { {'value' => "search-button", 'id' => ""} }
 
             before(:each) do
-              element.stub(:visible?).and_return(true)
-              element.stub(:text).and_return("")
-              buttons.page.stub(:all).with('button').and_return([element])
+              allow(element).to receive(:visible?).and_return(true)
+              allow(element).to receive(:text).and_return("")
+              allow(buttons.page).to receive(:all).with('button').and_return([element])
             end
 
             it "highlights the element" do
-              buttons.page.should_receive(:execute_script).twice
+              expect(buttons.page).to receive(:execute_script).twice
               buttons.get
             end
 
             it "returns the element in the array using the value as both the name and the selector" do
-              buttons.page.stub(:execute_script).and_return(nil)
-              buttons.get.should have(1).button
-              buttons.get.each.first.name.should == "search-button"
-              buttons.get.each.first.selector.should == "search-button"
+              allow(buttons.page).to receive(:execute_script).and_return(nil)
+              expect(buttons.get.size).to eq(1)
+              expect(buttons.get.each.first.name).to eq("search-button")
+              expect(buttons.get.each.first.selector).to eq("search-button")
             end
           end
 
@@ -85,14 +85,14 @@ module Swamp
             let(:element) { {'value' => "", 'id' => ""} }
 
             before(:each) do
-              element.stub(:visible?).and_return(true)
-              element.stub(:text).and_return("")
-              buttons.page.stub(:all).with('button').and_return([element])
+              allow(element).to receive(:visible?).and_return(true)
+              allow(element).to receive(:text).and_return("")
+              allow(buttons.page).to receive(:all).with('button').and_return([element])
             end
 
             it "returns an empty array" do
-              buttons.stub(:all).with('button').and_return([element])
-              buttons.get.should == []
+              allow(buttons).to receive(:all).with('button').and_return([element])
+              expect(buttons.get).to eq([])
             end
           end
         end
@@ -102,10 +102,10 @@ module Swamp
     context "when the button element is not visible" do
       it "returns an empty array" do
         element = {'id' => "u_0_2"}
-        element.stub(:text).and_return("Sign Up")
-        element.stub(:visible?).and_return(false)
-        buttons.page.stub(:all).with('button').and_return([element])
-        buttons.get.should == []
+        allow(element).to receive(:text).and_return("Sign Up")
+        allow(element).to receive(:visible?).and_return(false)
+        allow(buttons.page).to receive(:all).with('button').and_return([element])
+        expect(buttons.get).to eq([])
       end
     end
   end

data/spec/swamp/evaluator_spec.rb

@@ -9,7 +9,7 @@ module Swamp
           it "returns true" do
             input = "http://fakepage.com"
             evaluator = Swamp::Evaluator.new(input, wrapper)
-            evaluator.should be_valid_url
+            expect(evaluator).to be_valid_url
           end
         end
 
@@ -17,7 +17,7 @@ module Swamp
           it "returns true" do
             input = "https://fakepage.com"
             evaluator = Swamp::Evaluator.new(input, wrapper)
-            evaluator.should be_valid_url
+            expect(evaluator).to be_valid_url
           end
         end
 
@@ -25,7 +25,7 @@ module Swamp
           it "returns true" do
             input = "file://fakepage.html"
             evaluator = Swamp::Evaluator.new(input, wrapper)
-            evaluator.should be_valid_url
+            expect(evaluator).to be_valid_url
           end
         end
       end
@@ -35,7 +35,7 @@ module Swamp
           it "returns false" do
             input = "www.fakepage.com"
             evaluator = Swamp::Evaluator.new(input, wrapper)
-            evaluator.should_not be_valid_url
+            expect(evaluator).not_to be_valid_url
           end
         end
       end
@@ -45,29 +45,29 @@ module Swamp
       context "when the input is an enter keystroke" do
         context "when a page was already visited" do
           it "returns true" do
-            wrapper.stub(:page_visited).and_return(true)
+            allow(wrapper).to receive(:page_visited).and_return(true)
             input = "\n"
             evaluator = Swamp::Evaluator.new(input, wrapper)
-            evaluator.should be_refresh_command
+            expect(evaluator).to be_refresh_command
           end
         end
 
         context "when no page was yet visited" do
           it "returns false" do
-            wrapper.stub(:page_visited).and_return(false)
+            allow(wrapper).to receive(:page_visited).and_return(false)
             input = "\n"
             evaluator = Swamp::Evaluator.new(input, wrapper)
-            evaluator.should_not be_refresh_command
+            expect(evaluator).not_to be_refresh_command
           end
         end
       end
 
       context "when the input is not an enter keystroke" do
         it "returns false" do
-          wrapper.stub(:page_visited).and_return(true)
+          allow(wrapper).to receive(:page_visited).and_return(true)
           input = " "
           evaluator = Swamp::Evaluator.new(input, wrapper)
-          evaluator.should_not be_refresh_command
+          expect(evaluator).not_to be_refresh_command
         end
       end
     end

data/spec/swamp/fields_spec.rb

@@ -5,9 +5,9 @@ module Swamp
 
     it "delegates to capybara the responsibility to get the fields" do
       element = {'name' => "username", 'type' => "text"}
-      element.stub(:visible?).and_return(true)
-      fields.page.stub(:execute_script).and_return(nil)
-      fields.page.should_receive(:all).with('input').and_return([element])
+      allow(element).to receive(:visible?).and_return(true)
+      allow(fields.page).to receive(:execute_script).and_return(nil)
+      expect(fields.page).to receive(:all).with('input').and_return([element])
       fields.get
     end
 
@@ -19,25 +19,25 @@ module Swamp
           let (:element) { {'name' => "username", 'type' => type, 'id' => "u_0_b"} }
 
           before(:each) do
-            element.stub(:visible?).and_return(true)
-            fields.page.stub(:all).with('input').and_return([element])
+            allow(element).to receive(:visible?).and_return(true)
+            allow(fields.page).to receive(:all).with('input').and_return([element])
           end
 
           it "highlights the element" do
-            fields.page.should_receive(:execute_script).twice
+            expect(fields.page).to receive(:execute_script).twice
             fields.get
           end
 
           it "returns the element in the array using the name as the method's name" do
-            fields.page.stub(:execute_script).and_return(nil)
-            fields.get.should have(1).field
-            fields.get.first.name.should == "username"
+            allow(fields.page).to receive(:execute_script).and_return(nil)
+            expect(fields.get.size).to eq(1)
+            expect(fields.get.first.name).to eq("username")
           end
 
           it "returns the element in the array using the id as the selector" do
-            fields.page.stub(:execute_script).and_return(nil)
-            fields.get.should have(1).field
-            fields.get.first.selector.should == "u_0_b"
+            allow(fields.page).to receive(:execute_script).and_return(nil)
+            expect(fields.get.size).to eq(1)
+            expect(fields.get.first.selector).to eq("u_0_b")
           end
         end
 
@@ -45,25 +45,25 @@ module Swamp
           let (:element) { {'type' => type, 'id' => "username"} }
 
           before(:each) do
-            element.stub(:visible?).and_return(true)
-            fields.page.stub(:all).with('input').and_return([element])
+            allow(element).to receive(:visible?).and_return(true)
+            allow(fields.page).to receive(:all).with('input').and_return([element])
           end
 
           it "highlights the element" do
-            fields.page.should_receive(:execute_script).twice
+            expect(fields.page).to receive(:execute_script).twice
             fields.get
           end
 
           it "returns the element in the array using the id as the method's name" do
-            fields.page.stub(:execute_script).and_return(nil)
-            fields.get.should have(1).field
-            fields.get.first.name.should == "username"
+            allow(fields.page).to receive(:execute_script).and_return(nil)
+            expect(fields.get.size).to eq(1)
+            expect(fields.get.first.name).to eq("username")
           end
 
           it "returns the element in the array using the id as the selector" do
-            fields.page.stub(:execute_script).and_return(nil)
-            fields.get.should have(1).field
-            fields.get.first.selector.should == "username"
+            allow(fields.page).to receive(:execute_script).and_return(nil)
+            expect(fields.get.size).to eq(1)
+            expect(fields.get.first.selector).to eq("username")
           end
         end
 
@@ -71,25 +71,25 @@ module Swamp
           let (:element) { {'name' => "username", 'type' => type} }
 
           before(:each) do
-            element.stub(:visible?).and_return(true)
-            fields.page.stub(:all).with('input').and_return([element])
+            allow(element).to receive(:visible?).and_return(true)
+            allow(fields.page).to receive(:all).with('input').and_return([element])
           end
 
           it "highlights the element" do
-            fields.page.should_receive(:execute_script).twice
+            expect(fields.page).to receive(:execute_script).twice
             fields.get
           end
 
           it "returns the element in the array using the name as the method's name" do
-            fields.page.stub(:execute_script).and_return(nil)
-            fields.get.should have(1).field
-            fields.get.first.name.should == "username"
+            allow(fields.page).to receive(:execute_script).and_return(nil)
+            expect(fields.get.size).to eq(1)
+            expect(fields.get.first.name).to eq("username")
           end
 
           it "returns the element in the array using the name as the selector" do
-            fields.page.stub(:execute_script).and_return(nil)
-            fields.get.should have(1).field
-            fields.get.first.selector.should == "username"
+            allow(fields.page).to receive(:execute_script).and_return(nil)
+            expect(fields.get.size).to eq(1)
+            expect(fields.get.first.selector).to eq("username")
           end
         end
       end
@@ -99,9 +99,9 @@ module Swamp
 
         it "returns an empty array" do
           element = {'name' => "username", 'type' => type}
-          element.stub(:visible?).and_return(true)
-          fields.page.stub(:all).with('input').and_return([element])
-          fields.get.should == []
+          allow(element).to receive(:visible?).and_return(true)
+          allow(fields.page).to receive(:all).with('input').and_return([element])
+          expect(fields.get).to eq([])
         end
       end
     end
@@ -109,9 +109,9 @@ module Swamp
     context "when the input element is not visible" do
       it "returns an empty array" do
         element = {'name' => "username", 'type' => "text"}
-        element.stub(:visible?).and_return(false)
-        fields.page.stub(:all).with('input').and_return([element])
-        fields.get.should == []
+        allow(element).to receive(:visible?).and_return(false)
+        allow(fields.page).to receive(:all).with('input').and_return([element])
+        expect(fields.get).to eq([])
       end
     end
   end