net-ip 0.0.4 → 0.0.5

data/README.md

@@ -4,20 +4,22 @@
 [![Code Climate](https://codeclimate.com/github/jbussdieker/ruby-net-ip.png)](https://codeclimate.com/github/jbussdieker/ruby-net-ip)
 [![Gem Version](https://badge.fury.io/rb/net-ip.png)](http://badge.fury.io/rb/net-ip)
 
-Tools for working with IP routes
+Tools for working with IP routes and rules
 
 ## Usage
 
+### Routes
+
 ````ruby
 require 'net/ip'
 
-Net::IP::Route.flush(:cache)
+Net::IP.routes.flush(:cache)
 
-Net::IP::Route.each do |route|
+Net::IP.routes.each do |route|
   puts route
 end
 
-Net::IP::Route.find_gateways("eth0").each do |gateway|
+Net::IP.routes.find_gateways.each do |gateway|
   puts gateway.via
 end
 
@@ -25,5 +27,18 @@ gws = ["192.168.0.1", "192.168.0.2"].collect do |ip|
   Net::IP::Route.new(:via => ip, :dev => "eth0", :weight => 1)
 end
 
-Net::IP::Route.update_gateways(gws)
+Net::IP.routes.update_gateways(gws)
+````
+
+### Rules
+
+````ruby
+require 'net/ip'
+
+Net::IP.rules.each do |rule|
+  puts rule
+end
+
+rule = Net::IP::Rule.new(:to => '1.1.1.1', :table => 'custom')
+Net::IP.rules.add(rule)
 ````

data/lib/net/ip/route/collection.rb

@@ -0,0 +1,68 @@
+require "net/ip/route"
+require "net/ip/route/parser"
+
+module Net
+  module IP
+    class Route
+      class Collection
+        include Enumerable
+
+        def initialize(table = "main")
+          @table = table
+        end
+
+        # Enumerate all routes
+        # @yield {Route}
+        # @return {void}
+        def each(&block)
+          Parser.parse(`ip route show table #{@table}`).each {|r| yield(Route.new(r))}
+        end
+
+        # Get a list of all routes
+        # @return {Array<Route>}
+        def all
+          Parser.parse(`ip route show table #{@table}`).collect {|r| Route.new(r)}
+        end
+
+        # Get a list of all default gateway routes
+        # @return {Array<Route>}
+        def gateways
+          find_all {|r| r.prefix == "default"}
+        end
+
+        # Update the list of default gateways
+        # @example Change the default gateway to 192.168.0.1
+        #  gateway = Net::IP::Route.new(:prefix => 'default', :via => '192.168.0.1')
+        #  Net::IP::Route.update_gateways([gateway])
+        # @param gateways {Array<Route>} List of default gateways to use.
+        # @return {void}
+        def update_gateways(gateways)
+          params = gateways.collect {|gateway| "nexthop " + gateway.to_params}
+          result = `ip route replace default #{params.join(" ")}`
+          raise result unless $?.success?
+        end
+
+        # Add a route to the routing table
+        # @example Create a route to the 10.0.0.0/8 network
+        #  route = Net::IP::Route.new(:prefix => '10.0.0.0/8', :dev => 'eth0')
+        #  Net::IP::Route.add_route(route)
+        # @param route {Route} Route to add to the table.
+        # @return {void}
+        def add(route)
+          result = `ip route add #{route.to_params}`
+          raise result unless $?.success?
+        end
+
+        # Flush the routing table based on a selector
+        # @example Flush the routing table cache
+        #  Net::IP::Route.flush(:cache)
+        # @param selector {String} The selector string.
+        # @return {void}
+        def flush(selector)
+          result = `ip route flush #{selector}`
+          raise result unless $?.success?
+        end
+      end
+    end
+  end
+end

data/lib/net/ip/route/parser.rb

@@ -0,0 +1,61 @@
+require "net/ip/route"
+
+module Net
+  module IP
+    class Route
+      # Parses routing table entries
+      class Parser
+        # Parse a routing table entry into a hash
+        #
+        # @param line {String}
+        # @return {Hash}
+        def self.parse_line(line)
+          params = {}
+
+          if line =~ /^(unicast|unreachable|blackhole|prohibit|local|broadcast|throw|nat|via|anycast|multicast)\s+/
+            params[:type] = $1
+            line = line[$1.length..-1]
+          end
+
+          params[:prefix] = line.split.first
+          params[:dev] = $1 if line =~ /\s+dev\s+([^\s]+)/
+          params[:scope] = $1 if line =~ /\s+scope\s+([^\s]+)/
+          params[:metric] = $1 if line =~ /\s+metric\s+([^\s]+)/
+          params[:proto] = $1 if line =~ /\s+proto\s+([^\s]+)/
+          params[:src] = $1 if line =~ /\s+src\s+([^\s]+)/
+          params[:via] = $1 if line =~ /\s+via\s+([^\s]+)/
+          params[:weight] = $1 if line =~ /\s+weight\s+([^\s]+)/
+          params[:table] = $1 if line =~ /\s+table\s+([^\s]+)/
+          params[:error] = $1 if line =~ /\s+error\s+([^\s]+)/
+
+          params
+        end
+
+        # Parse the output of ip route into an array of hashes
+        #
+        # @param data {String}
+        # @return {Array}
+        def self.parse(data)
+          list = []
+          in_default = false
+          data.each_line do |line|
+            if in_default == true
+              if line.start_with? "\t"
+                list << parse_line(line.strip.gsub("nexthop", "default"))
+              else
+                in_default = false
+              end
+            elsif line.strip == "default"
+              in_default = true
+            end
+
+            unless in_default
+              list << parse_line(line.strip)
+            end
+          end
+          list
+        end
+      end
+    end
+  end
+end

data/lib/net/ip/route.rb

@@ -2,89 +2,32 @@ module Net
   module IP
     # Class for working with routing table entries.
     class Route
-      attr_accessor :type, :prefix, :dev, :scope, :metric, 
-                    :proto, :src, :via, :weight, :table, :error
-
-      extend Enumerable
+      attr_reader :prefix
 
       # Create a new route object
       # @example Create a default route
       #  Net::IP::Route.new(:prefix => 'default', :via => '192.168.0.1')
       # @example Create a normal route
       #  Net::IP::Route.new(:prefix => '10.0.0.0/8', :dev => 'eth0')
-      # @note This does NOT add the entry to the routing table. See {add_route} for creating new routes in the routing table.
+      # @note This does NOT add the entry to the routing table. See {Route::Collection#add} for creating new routes in the routing table.
       # @param params {Hash}
       def initialize(params = {})
         params.each do |k,v|
-          send("#{k}=", v)
+          instance_variable_set("@#{k}", v)
         end
       end
 
-      # Enumerate all routes
-      # @yield {Route}
-      # @return {void}
-      def self.each(&block)
-        RouteParser.parse(`ip route`).each {|r| yield(new(r))}
-      end
-
-      # Get a list of all routes
-      # @return {Array<Route>}
-      def self.all
-        RouteParser.parse(`ip route`).collect {|r| new(r)}
-      end
-
-      # Get a list of all default gateway routes
-      # @return {Array<Route>}
-      def self.find_gateways
-        find_all {|r| r.prefix == "default"}
-      end
-
-      # Update the list of default gateways
-      # @example Change the default gateway to 192.168.0.1
-      #  gateway = Net::IP::Route.new(:prefix => 'default', :via => '192.168.0.1')
-      #  Net::IP::Route.update_gateways([gateway])
-      # @param gateways {Array<Route>} List of default gateways to use.
-      # @return {void}
-      def self.update_gateways(gateways)
-        params = gateways.collect {|gateway| "nexthop " + gateway.build_param_string}
-        result = `ip route replace default #{params.join(" ")}`
-        raise result unless $?.success?
-      end
-
-      # Add a route to the routing table
-      # @example Create a route to the 10.0.0.0/8 network
-      #  route = Net::IP::Route.new(:prefix => '10.0.0.0/8', :dev => 'eth0')
-      #  Net::IP::Route.add_route(route)
-      # @param route {Route} Route to add to the table.
-      # @return {void}
-      def self.add_route(route)
-        result = `ip route add #{route.build_param_string}`
-        raise result unless $?.success?
-      end
-
-      # Flush the routing table based on a selector
-      # @example Flush the routing table cache
-      #  Net::IP::Route.flush(:cache)
-      # @param selector {String} The selector string.
-      # @return {void}
-      def self.flush(selector)
-        result = `ip route flush #{selector}`
-        raise result unless $?.success?
-      end
-
-private
-
-      def build_param_string
+      def to_params
         str = ""
-        str << "via #{via} " if via
-        str << "dev #{dev} " if dev
-        str << "weight #{weight}" if weight
-        str << " table #{table} " if table
-        str << " proto #{proto} " if proto
-        str << " scope #{scope} " if scope
-        str << " src #{src} " if src
-        str << " metric #{metric} " if metric
-        str << " error #{error}" if error
+        str << "via #{@via} " if @via
+        str << "dev #{@dev} " if @dev
+        str << "weight #{@weight}" if @weight
+        str << " table #{@table} " if @table
+        str << " proto #{@proto} " if @proto
+        str << " scope #{@scope} " if @scope
+        str << " src #{@src} " if @src
+        str << " metric #{@metric} " if @metric
+        str << " error #{@error}" if @error
         str
       end
     end

data/lib/net/ip/rule/collection.rb

@@ -0,0 +1,41 @@
+require "net/ip/rule"
+require "net/ip/rule/parser"
+
+module Net
+  module IP
+    class Rule
+      class Collection
+        include Enumerable
+
+        # Enumerate all rules
+        # @yield {Rule}
+        # @return {void}
+        def each(&block)
+          Parser.parse(`ip rule list`).each {|r| yield(Rule.new(r))}
+        end
+
+        # Add a rule to the ip rule list
+        # @example Create a rule for 1.2.3.4 to use routing table 'custom'
+        #  rule = Net::IP::Rule.new(:to => '1.2.3.4', :table => 'custom')
+        #  Net::IP.rules.add_rule(rule)
+        # @param rule {Rule} Rule to add to the list.
+        # @return {void}
+        def add(rule)
+          result = `ip rule add #{rule.to_params}`
+          raise result unless $?.success?
+        end
+
+        # Delete a rule from the ip rule list
+        # @example Delete a rule for 1.2.3.4 using routing table 'custom'
+        #  rule = Net::IP::Rule.new(:to => '1.2.3.4', :table => 'custom')
+        #  Net::IP.rules.delete_rule(rule)
+        # @param rule {Rule} Rule to delete from the list.
+        # @return {void}
+        def delete(rule)
+          result = `ip rule delete #{rule.to_params}`
+          raise result unless $?.success?
+        end
+      end
+    end
+  end
+end

data/lib/net/ip/rule/parser.rb

@@ -0,0 +1,30 @@
+module Net
+  module IP
+    class Rule
+      class Parser
+        # Parse a rule entry into a hash
+        #
+        # @param line {String}
+        # @return {Hash}
+        def self.parse_line(line)
+          params = {}
+          params[:priority] = $1 if line =~ /^(\d+):\t/
+          params[:from] = $1 if line =~ /\s+from\s+([^\s]+)\s+/
+          params[:to] = $1 if line =~ /\s+to\s+([^\s]+)\s+/
+          params[:lookup] = $1 if line =~ /\s+lookup\s+([^\s]+)\s+/
+          params[:realms] = $1 if line =~ /\s+realms\s+([^\s]+)\s+/
+          params[:map_to] = $1 if line =~ /\s+map-to\s+([^\s]+)\s+/
+          params
+        end
+
+        def self.parse(data)
+          list = []
+          data.split("\n").each do |line|
+            list << parse_line(line)
+          end
+          list
+        end
+      end
+    end
+  end
+end

data/lib/net/ip/rule.rb

@@ -0,0 +1,23 @@
+module Net
+  module IP
+    # Class for working with ip rules.
+    class Rule
+      # Create a new rule object
+      # @example Create a rule to use a different route table
+      #  Net::IP::Rule.new(:to => '1.2.3.4', :table => 'custom')
+      # @note This does NOT add the entry to the ip rules. See {Rule::Collection#add} for creating new rules in the ip rule list.
+      # @param params {Hash}
+      def initialize(params = {})
+        params.each do |k,v|
+          instance_variable_set("@#{k}", v)
+        end
+      end
+
+      def to_params
+        str = ""
+        str << "priority #{@priority} " if @priority
+        str
+      end
+    end
+  end
+end

data/lib/net/ip/version.rb

@@ -1,5 +1,5 @@
 module Net
   module IP
-    VERSION = "0.0.4"
+    VERSION = "0.0.5"
   end
 end

data/lib/net/ip.rb

@@ -1,8 +1,19 @@
 require "net/ip/version"
-require "net/ip/route_parser"
-require "net/ip/route"
+require "net/ip/route/collection"
+require "net/ip/rule/collection"
 
 module Net
   module IP
+    # Get list of routes
+    # @return {Route::Collection}
+    def self.routes
+      Route::Collection.new
+    end
+
+    # Get list of rules
+    # @return {Rule::Collection}
+    def self.rules
+      Rule::Collection.new
+    end
   end
 end

data/net-ip.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.version       = Net::IP::VERSION
   spec.authors       = ["Joshua Bussdieker"]
   spec.email         = ["jbussdieker@gmail.com"]
-  spec.summary       = %q{Tools for working with IP routes}
+  spec.summary       = %q{Tools for working with IP routes and rules}
   spec.homepage      = "http://github.com/jbussdieker/ruby-net-ip"
   spec.license       = "MIT"
 

data/spec/net/ip/{route_parser_spec.rb → route/parser_spec.rb}

@@ -1,9 +1,9 @@
-require 'net/ip/route_parser'
+require 'net/ip/route/parser'
 
-describe Net::IP::RouteParser do
+describe Net::IP::Route::Parser do
   context "line parser" do
     def test_parse_line(line, field, expect)
-      h = Net::IP::RouteParser.parse_line(line)
+      h = Net::IP::Route::Parser.parse_line(line)
       h[field].should eql(expect)
     end
 
@@ -46,11 +46,11 @@ describe Net::IP::RouteParser do
 
   context "parser" do
     def test_parse(file, expect)
-      Net::IP::RouteParser.parse(File.read(file)).should eql(expect)
+      Net::IP::Route::Parser.parse(File.read(file)).should eql(expect)
     end
 
     it "handles sample 1" do
-      test_parse("spec/net/ip/sample1", [
+      test_parse("spec/net/ip/route/sample1", [
         {:prefix=>"default", :dev=>"eth0", :proto=>"static", :via=>"192.168.0.1"},
         {:prefix=>"169.254.0.0/16", :dev=>"eth0", :scope=>"link", :metric=>"1000"},
         {:prefix=>"192.168.0.0/24", :dev=>"eth0", :scope=>"link", :metric=>"1", :proto=>"kernel", :src=>"192.168.0.15"}
@@ -58,7 +58,7 @@ describe Net::IP::RouteParser do
     end
 
     it "handles sample 2" do
-      test_parse("spec/net/ip/sample2", [
+      test_parse("spec/net/ip/route/sample2", [
         {:prefix=>"default", :dev=>"eth0", :via=>"10.0.61.225", :weight=>"1"},
         {:prefix=>"default", :dev=>"eth0", :via=>"10.0.45.153", :weight=>"1"},
         {:prefix=>"10.0.0.0", :dev=>"eth0", :via=>"10.0.0.1"},
@@ -68,7 +68,7 @@ describe Net::IP::RouteParser do
     end
 
     it "handles sample 3" do
-      test_parse("spec/net/ip/sample3", [
+      test_parse("spec/net/ip/route/sample3", [
         {:prefix=>"default", :dev=>"eth0", :via=>"10.0.35.196"},
         {:prefix=>"10.0.0.0", :dev=>"eth0", :via=>"10.0.0.1"},
         {:prefix=>"10.0.0.0/18", :dev=>"eth0", :scope=>"link", :proto=>"kernel", :src=>"10.0.58.155"},
@@ -77,7 +77,7 @@ describe Net::IP::RouteParser do
     end
 
     it "handles sample 4" do
-      test_parse("spec/net/ip/sample4", [
+      test_parse("spec/net/ip/route/sample4", [
         {:prefix=>"default", :dev=>"eth0", :via=>"192.168.0.1"},
         {:prefix=>"169.254.0.0/16", :dev=>"eth0", :scope=>"link", :metric=>"1000"},
         {:prefix=>"192.168.0.0/24", :dev=>"eth0", :scope=>"link", :metric=>"1", :proto=>"kernel", :src=>"192.168.0.15"},

data/spec/net/ip/route_spec.rb

@@ -4,4 +4,8 @@ describe Net::IP::Route do
   it "should be creatable" do
     Net::IP::Route.new.should be_kind_of(Net::IP::Route)
   end
+
+  it "should be convert to_params" do
+    Net::IP::Route.new(:dev => 'eth0').to_params.should eql("dev eth0 ")
+  end
 end

data/spec/net/ip/rule/parser_spec.rb

@@ -0,0 +1,58 @@
+require 'net/ip/rule/parser'
+
+describe Net::IP::Rule::Parser do
+  context "line parser" do
+    def test_parse_line(line, field, expect)
+      h = Net::IP::Rule::Parser.parse_line(line)
+      h[field].should eql(expect)
+    end
+
+    it "should parse priority" do
+      test_parse_line("0:	from all lookup local ", :priority, "0")
+    end
+
+    it "should parse from" do
+      test_parse_line("0:	from all lookup local ", :from, "all")
+    end
+
+    it "should parse lookup" do
+      test_parse_line("0:	from all lookup local ", :lookup, "local")
+    end
+
+    it "should parse to" do
+      test_parse_line("32756:	from all to 1.2.3.1 lookup custom ", :to, "1.2.3.1")
+    end
+  end
+
+  context "parser" do
+    def test_parse(file, expect)
+      Net::IP::Rule::Parser.parse(File.read(file)).should eql(expect)
+    end
+
+    it "handles sample 1" do
+      test_parse("spec/net/ip/rule/sample1", [
+        {:priority=>"0", :from=>"all", :lookup=>"local"},
+        {:priority=>"32766", :from=>"all", :lookup=>"main"},
+        {:priority=>"32767", :from=>"all", :lookup=>"default"}
+      ])
+    end
+
+    it "handles sample 2" do
+      test_parse("spec/net/ip/rule/sample2", [
+        {:priority=>"0", :from=>"all", :lookup=>"local"},
+        {:priority=>"32756", :from=>"all", :to=>"1.2.3.1", :lookup=>"custom"},
+        {:priority=>"32757", :from=>"all", :to=>"1.2.3.2", :lookup=>"custom"},
+        {:priority=>"32758", :from=>"all", :to=>"1.2.3.3", :lookup=>"custom"},
+        {:priority=>"32759", :from=>"all", :to=>"1.2.3.4", :lookup=>"custom"},
+        {:priority=>"32760", :from=>"all", :to=>"1.2.3.5", :lookup=>"custom"},
+        {:priority=>"32761", :from=>"all", :to=>"1.2.3.6", :lookup=>"custom"},
+        {:priority=>"32762", :from=>"all", :to=>"1.2.3.7", :lookup=>"custom"},
+        {:priority=>"32763", :from=>"all", :to=>"1.2.3.8", :lookup=>"custom"},
+        {:priority=>"32764", :from=>"all", :to=>"1.2.3.9", :lookup=>"custom"},
+        {:priority=>"32765", :from=>"all", :to=>"1.2.3.10", :lookup=>"custom"},
+        {:priority=>"32766", :from=>"all", :lookup=>"main"},
+        {:priority=>"32767", :from=>"all", :lookup=>"default"}
+      ])
+    end
+  end
+end

data/spec/net/ip/rule/sample1

@@ -0,0 +1,3 @@
+0:	from all lookup local 
+32766:	from all lookup main 
+32767:	from all lookup default 

data/spec/net/ip/rule/sample2

@@ -0,0 +1,13 @@
+0:	from all lookup local 
+32756:	from all to 1.2.3.1 lookup custom 
+32757:	from all to 1.2.3.2 lookup custom 
+32758:	from all to 1.2.3.3 lookup custom 
+32759:	from all to 1.2.3.4 lookup custom 
+32760:	from all to 1.2.3.5 lookup custom 
+32761:	from all to 1.2.3.6 lookup custom 
+32762:	from all to 1.2.3.7 lookup custom 
+32763:	from all to 1.2.3.8 lookup custom 
+32764:	from all to 1.2.3.9 lookup custom 
+32765:	from all to 1.2.3.10 lookup custom 
+32766:	from all lookup main 
+32767:	from all lookup default 

data/spec/net/ip/rule_spec.rb

@@ -0,0 +1,11 @@
+require 'net/ip/rule'
+
+describe Net::IP::Rule do
+  it "should be creatable" do
+    Net::IP::Rule.new.should be_kind_of(Net::IP::Rule)
+  end
+
+  it "should be convert to_params" do
+    Net::IP::Rule.new(:priority => '1').to_params.should eql("priority 1 ")
+  end
+end

metadata

@@ -1,75 +1,71 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: net-ip
-version: !ruby/object:Gem::Version 
-  hash: 23
+version: !ruby/object:Gem::Version
+  version: 0.0.5
   prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 4
-  version: 0.0.4
 platform: ruby
-authors: 
+authors:
 - Joshua Bussdieker
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2013-08-09 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
+date: 2013-08-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 9
-        segments: 
-        - 1
-        - 3
-        version: "1.3"
-  name: bundler
-  prerelease: false
+      - !ruby/object:Gem::Version
+        version: '1.3'
   type: :development
-  requirement: *id001
-- !ruby/object:Gem::Dependency 
-  version_requirements: &id002 !ruby/object:Gem::Requirement 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
   name: rake
-  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  requirement: *id002
-- !ruby/object:Gem::Dependency 
-  version_requirements: &id003 !ruby/object:Gem::Requirement 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
   name: rspec
-  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  requirement: *id003
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
-email: 
+email:
 - jbussdieker@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - .travis.yml
 - Gemfile
@@ -78,52 +74,62 @@ files:
 - Rakefile
 - lib/net/ip.rb
 - lib/net/ip/route.rb
-- lib/net/ip/route_parser.rb
+- lib/net/ip/route/collection.rb
+- lib/net/ip/route/parser.rb
+- lib/net/ip/rule.rb
+- lib/net/ip/rule/collection.rb
+- lib/net/ip/rule/parser.rb
 - lib/net/ip/version.rb
 - net-ip.gemspec
-- spec/net/ip/route_parser_spec.rb
+- spec/net/ip/route/parser_spec.rb
+- spec/net/ip/route/sample1
+- spec/net/ip/route/sample2
+- spec/net/ip/route/sample3
+- spec/net/ip/route/sample4
 - spec/net/ip/route_spec.rb
-- spec/net/ip/sample1
-- spec/net/ip/sample2
-- spec/net/ip/sample3
-- spec/net/ip/sample4
+- spec/net/ip/rule/parser_spec.rb
+- spec/net/ip/rule/sample1
+- spec/net/ip/rule/sample2
+- spec/net/ip/rule_spec.rb
 homepage: http://github.com/jbussdieker/ruby-net-ip
-licenses: 
+licenses:
 - MIT
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+      hash: -1307484347518193870
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
+      hash: -1307484347518193870
 requirements: []
-
 rubyforge_project: 
 rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
-summary: Tools for working with IP routes
-test_files: 
-- spec/net/ip/route_parser_spec.rb
+summary: Tools for working with IP routes and rules
+test_files:
+- spec/net/ip/route/parser_spec.rb
+- spec/net/ip/route/sample1
+- spec/net/ip/route/sample2
+- spec/net/ip/route/sample3
+- spec/net/ip/route/sample4
 - spec/net/ip/route_spec.rb
-- spec/net/ip/sample1
-- spec/net/ip/sample2
-- spec/net/ip/sample3
-- spec/net/ip/sample4
+- spec/net/ip/rule/parser_spec.rb
+- spec/net/ip/rule/sample1
+- spec/net/ip/rule/sample2
+- spec/net/ip/rule_spec.rb

data/lib/net/ip/route_parser.rb

@@ -1,57 +0,0 @@
-module Net
-  module IP
-    # Parses routing table entries
-    class RouteParser
-      # Parse a routing table entry into a hash
-      #
-      # @param line {String}
-      # @return {Hash}
-      def self.parse_line(line)
-        params = {}
-
-        if line =~ /^(unicast|unreachable|blackhole|prohibit|local|broadcast|throw|nat|via|anycast|multicast)\s+/
-          params[:type] = $1
-          line = line[$1.length..-1]
-        end
-
-        params[:prefix] = line.split.first
-        params[:dev] = $1 if line =~ /\s+dev\s+([^\s]+)/
-        params[:scope] = $1 if line =~ /\s+scope\s+([^\s]+)/
-        params[:metric] = $1 if line =~ /\s+metric\s+([^\s]+)/
-        params[:proto] = $1 if line =~ /\s+proto\s+([^\s]+)/
-        params[:src] = $1 if line =~ /\s+src\s+([^\s]+)/
-        params[:via] = $1 if line =~ /\s+via\s+([^\s]+)/
-        params[:weight] = $1 if line =~ /\s+weight\s+([^\s]+)/
-        params[:table] = $1 if line =~ /\s+table\s+([^\s]+)/
-        params[:error] = $1 if line =~ /\s+error\s+([^\s]+)/
-
-        params
-      end
-
-      # Parse the output of ip route into an array of hashes
-      #
-      # @param data {String}
-      # @return {Array}
-      def self.parse(data)
-        list = []
-        in_default = false
-        data.each_line do |line|
-          if in_default == true
-            if line.start_with? "\t"
-              list << parse_line(line.strip.gsub("nexthop", "default"))
-            else
-              in_default = false
-            end
-          elsif line.strip == "default"
-            in_default = true
-          end
-
-          unless in_default
-            list << parse_line(line.strip)
-          end
-        end
-        list
-      end
-    end
-  end
-end