Use software_version instead of just version for consistency (closes

 #148).

lib/ronin/exploits/mixins/has_targets.rb

@@ -172,15 +172,15 @@ def perform_validate
         # @param [Symbol] software
         #   The targeted software.
         #
-        # @param [Symbol] version
+        # @param [Symbol] software_version
         #   The targeted software version.
         #
         # @raise [NoMatchingTarget]
         #   No matching target could be found.
         #
         # @api semipublic
         #
-        def select_target(arch: nil, os: nil, os_version: nil, software: nil, version: nil)
+        def select_target(arch: nil, os: nil, os_version: nil, software: nil, software_version: nil)
           targets = self.class.targets.lazy
 
           if arch
@@ -199,9 +199,9 @@ def select_target(arch: nil, os: nil, os_version: nil, software: nil, version: n
             targets = targets.select { |target| target.software == software }
           end
 
-          if version
+          if software_version
             targets = targets.select do |target|
-              target.version == version
+              target.software_version == software_version
             end
           end
 
@@ -289,9 +289,13 @@ def software
         #
         # @api public
         #
-        def version
-          target.version if target
+        # @since 1.2.0
+        #
+        def software_version
+          target.software_version if target
         end
+
+        alias version software_version
       end
     end
   end

lib/ronin/exploits/target.rb

@@ -54,7 +54,11 @@ class Target < OpenStruct
       # The target's software version.
       #
       # @return [String, nil]
-      attr_reader :version
+      #
+      # @since 1.2.0
+      attr_reader :software_version
+
+      alias version software_version
 
       #
       # Creates a new ExploitTarget object
@@ -71,20 +75,24 @@ class Target < OpenStruct
       # @param [String, nil] software
       #   The software name of the target (ex: `"Apache"`).
       #
-      # @param [String, nil] version
+      # @param [String, nil] software_version
       #   The software version of the target (ex: `"2.4.54"`).
       #
+      # @param [String, nil] version
+      #   Alias for `software_version:`.
+      #
       # @yield [target]
       #   If a block is given, it will be passed the new target object.
       #
       # @yieldparam [Target] target
       #   The newly created target object.
       #
-      def initialize(arch:       nil,
-                     os:         nil,
-                     os_version: nil,
-                     software:   nil,
-                     version:    nil,
+      def initialize(arch:             nil,
+                     os:               nil,
+                     os_version:       nil,
+                     software:         nil,
+                     software_version: nil,
+                     version:          nil,
                      **params)
         super(**params)
 
@@ -93,8 +101,8 @@ def initialize(arch:       nil,
         @os         = os
         @os_version = os_version
 
-        @software = software
-        @version  = version
+        @software          = software
+        @software_version  = software_version || version
 
         yield self if block_given?
       end

spec/mixins/has_targets_spec.rb

@@ -122,14 +122,14 @@ class ExampleExploit < Ronin::Exploits::Exploit
              os: :linux,
              os_version: '5.18.1',
              software: 'Apache',
-             version: '2.4.53',
+             software_version: '2.4.53',
              foo: 1
 
       target arch: :arm,
              os: :macos,
              os_version: '10.13',
              software: 'nginx',
-             version: '1.22.0',
+             software_version: '1.22.0',
              foo: 2
     end
   end
@@ -289,37 +289,37 @@ class ExampleExploit < Ronin::Exploits::Exploit
       end
     end
 
-    context "when given the version: keyword argument" do
-      let(:version) { '1.22.0' }
+    context "when given the software_version: keyword argument" do
+      let(:software_version) { '1.22.0' }
 
-      it "must find the target in .targets with the matching #version" do
-        subject.select_target(version: version)
+      it "must find the target in .targets with the matching #software_version" do
+        subject.select_target(software_version: software_version)
 
-        expect(subject.target.version).to eq(version)
+        expect(subject.target.software_version).to eq(software_version)
       end
     end
 
     context "when given multiple keyword arguments" do
-      let(:arch)       { :arm     }
-      let(:os)         { :macos   }
-      let(:os_version) { '10.13'  }
-      let(:software)   { 'nginx'  }
-      let(:version)    { '1.22.0' }
+      let(:arch)             { :arm     }
+      let(:os)               { :macos   }
+      let(:os_version)       { '10.13'  }
+      let(:software)         { 'nginx'  }
+      let(:software_version) { '1.22.0' }
 
       it "must find the target in .targets which matches all given values" do
         subject.select_target(
           arch:             arch,
           os:               os,
           os_version:       os_version,
           software:         software,
-          version: version
+          software_version: software_version
         )
 
-        expect(subject.target.arch).to       eq(arch)
-        expect(subject.target.os).to         eq(os)
-        expect(subject.target.os_version).to eq(os_version)
-        expect(subject.target.software).to   eq(software)
-        expect(subject.target.version).to    eq(version)
+        expect(subject.target.arch).to             eq(arch)
+        expect(subject.target.os).to               eq(os)
+        expect(subject.target.os_version).to       eq(os_version)
+        expect(subject.target.software).to         eq(software)
+        expect(subject.target.software_version).to eq(software_version)
       end
     end
 
@@ -412,22 +412,22 @@ class ExampleExploit < Ronin::Exploits::Exploit
     end
   end
 
-  describe "#version" do
+  describe "#software_version" do
     context "when a target has been set" do
       subject do
-        test_class.new(target: {version: '1.22.0'})
+        test_class.new(target: {software_version: '1.22.0'})
       end
 
-      it "must return the #target's #version" do
-        expect(subject.version).to eq(subject.target.version)
+      it "must return the #target's #software_version" do
+        expect(subject.software_version).to eq(subject.target.software_version)
       end
     end
 
     context "when no target has been set" do
       subject { test_class.new }
 
       it "must return nil" do
-        expect(subject.version).to be(nil)
+        expect(subject.software_version).to be(nil)
       end
     end
   end

spec/target_spec.rb

@@ -23,6 +23,10 @@
       expect(subject.software).to be(nil)
     end
 
+    it "must default #software_version to nil" do
+      expect(subject.software_version).to be(nil)
+    end
+
     it "must default #version to nil" do
       expect(subject.version).to be(nil)
     end
@@ -67,12 +71,30 @@
       end
     end
 
+    context "when given the software_version: keyword argument" do
+      let(:software_version) { '1.2.3' }
+
+      subject { described_class.new(software_version: software_version) }
+
+      it "must set #software_version" do
+        expect(subject.software_version).to be(software_version)
+      end
+
+      it "must also set #version" do
+        expect(subject.software_version).to be(software_version)
+      end
+    end
+
     context "when given the version: keyword argument" do
       let(:version) { '1.2.3' }
 
       subject { described_class.new(version: version) }
 
-      it "must set #version" do
+      it "must set #software_version" do
+        expect(subject.software_version).to be(version)
+      end
+
+      it "must also set #version" do
         expect(subject.version).to be(version)
       end
     end