cisco_acl_intp 0.0.2 → 0.0.3

data/lib/cisco_acl_intp/ace_port.rb

@@ -1,36 +1,25 @@
 # -*- coding: utf-8 -*-
-
+require 'forwardable'
 require 'cisco_acl_intp/ace_proto'
+require 'cisco_acl_intp/ace_port_opr'
 
 module CiscoAclIntp
   # IP(TCP/UDP) port number and operator container
   class AcePortSpec < AclContainerBase
-    # @param [String] value Operator of port (eq/neq/gt/lt/range)
-    # @return [String]
-    attr_reader :operator
-
-    # @param [Symbol] value Protocol name [:tcp, :udp]
-    # @return [String]
-    attr_reader :protocol
-
-    # @param [AceProtoSpecBase] value Port No. (single/lower)
-    # @return [AceProtoSpecBase]
-    attr_reader :begin_port
+    extend Forwardable
 
-    # alias for unary operator
-    alias_method :port, :begin_port
-
-    # @param [AceProtoSpecBase] value Port No. (higher)
-    # @return [AceProtoSpecBase]
-    attr_reader :end_port
+    # @return [AcePortOperatorBase] value Port-set operator
+    attr_reader :operator
+    def_delegators :@operator, :begin_port, :port, :end_port, :to_s
 
     # Constructor
     # @param [Hash] opts Options
-    # @option opts [String] :operator Port operator, eq/neq/lt/gt/range
-    # @option opts [AceProtoSpecBase] :port Port No. (single/lower)
+    # @option opts [String, Symbol] :operator Port operator,
+    #   (any, strict_anyeq, neq, lt, gt, range)
+    # @option opts [AceProtoSpecBase] :port Port (single/lower)
     #   (same as :begin_port, alias for unary operator)
-    # @option opts [AceProtoSpecBase] :begin_port Port No. (single/lower)
-    # @option opts [AceProtoSpecBase] :end_port Port No. (higher)
+    # @option opts [AceProtoSpecBase] :begin_port Port (single/lower)
+    # @option opts [AceProtoSpecBase] :end_port Port (higher)
     # @raise [AclArgumentError]
     # @return [AcePortSpec]
     # @note '@begin_port' and '@end_port' should managed
@@ -39,10 +28,9 @@ module CiscoAclIntp
     #   and need the name when stringize the object.
     # @todo in ACL, can "eq/neq" receive port list? IOS15 later?
     def initialize(opts)
-      @protocol = :tcp_udp
       if opts.key?(:operator)
         @options = opts
-        validate_operators
+        define_operator_and_ports
       else
         fail AclArgumentError, 'Not specified port operator'
       end
@@ -51,178 +39,45 @@ module CiscoAclIntp
     # @param [AcePortSpec] other RHS Object
     # @return [Boolean]
     def ==(other)
-      @protocol == other.protocol &&
-        @operator == other.operator &&
-        @begin_port == other.begin_port &&
-        @end_port == other.end_port
-    end
-
-    # Generate string for Cisco IOS access list
-    # @return [String]
-    def to_s
-      if @operator == 'any'
-        ''
-      else
-        tag_port(
-          clean_acl_string(
-            sprintf('%s %s %s', @operator, @begin_port, @end_port)
-          )
-        )
-      end
+      @operator == other.operator
     end
 
-    # Table of port match operator and operations
-    PORT_OPERATE = {
-      'any'   => proc do |begin_port, end_port, port|
-        true
-      end,
-      'eq'    => proc do |begin_port, end_port, port|
-        begin_port == port
-      end,
-      'neq'   => proc do |begin_port, end_port, port|
-        begin_port != port
-      end,
-      'gt'    => proc do |begin_port, end_port, port|
-        begin_port  < port
-      end,
-      'lt'    => proc do |begin_port, end_port, port|
-        begin_port  > port
-      end,
-      'range' => proc do |begin_port, end_port, port|
-        (begin_port .. end_port).include?(port)
-      end
-    }
-
-    # Check the port number matches this?
-    # @param [Integer,String] port TCP/UDP Port No./Name
+    # Check if self contains other port-set?
+    # @param [AcePortSpec] other TCP/UDP Port spec
     # @raise [AclArgumentError]
     # @return [Boolean]
-    def matches?(port)
-      port = case port
-             when String
-               if port =~ /\d+/
-                 convert_proto_spec_by_number(port.to_i)
-               else
-                 convert_proto_spec_by_name(port)
-               end
-             else
-               convert_proto_spec_by_number(port)
-             end
-      # @operator was validated in constructor
-      PORT_OPERATE[@operator].call(@begin_port.to_i, @end_port.to_i, port.to_i)
+    def contains?(other)
+      @operator.contains?(other.operator)
     end
 
     private
 
-    # Convert from port name string to AceProtoSpecBase object
-    # @param [String] name TCP/UDP Port Name
-    # @raise [AclArgumentError]
-    # @return [AceProtoSpecBase]
-    def convert_proto_spec_by_name(name)
-      fail AclArgumentError, sprintf(
-        'Cannot judge port name: %s, w/protocol: %s',
-        name, @protocol
-      )
-    end
-
-    # Convert from port number integer to AceTcpUdpProtoSpec object
-    # @param [Integer] number TCP Port Number
-    # @raise [AclArgumentError]
-    # @return [AceProtoSpecBase]
-    def convert_proto_spec_by_number(number)
-      AceTcpUdpProtoSpec.new(number: number)
-    end
+    # Port set operator table
+    OPERATOR_CLASS = {
+      strict_any: AcePortOpStrictAny,
+      any: AcePortOpAny,
+      eq: AcePortOpEq,
+      neq: AcePortOpNeq,
+      lt: AcePortOpLt,
+      gt: AcePortOpGt,
+      range: AcePortOpRange
+    }
 
     # Set instance variables
-    def define_operator_and_ports
-      @operator = @options[:operator] || 'any'
-      @begin_port = @options[:port] || @options[:begin_port] || nil
-      @end_port = @options[:end_port] || nil
-    end
-
-    # Varidate options
     # @raise [AclArgumentError]
-    def validate_operators
-      define_operator_and_ports
-
-      if !PORT_OPERATE.key?(@operator)
-        fail AclArgumentError, "Unknown operator: #{@operator}"
-      elsif !valid_operator_and_port?
-        fail AclArgumentError, 'Invalid port or ports sequence'
-      end
-    end
-
-    # Varidate combination operator and port number
-    # @return [Boolean]
-    def valid_operator_and_port?
-      case @operator
-      when 'any'
-        true
-      when 'range'
-        @begin_port &&
-          @end_port &&
-          @begin_port < @end_port
+    # @return [AcePortOperatorBase] Port set operator object.
+    def define_operator_and_ports
+      opr = @options.key?(:operator) ? @options[:operator].intern : :any
+      if OPERATOR_CLASS.key?(opr)
+        @operator = OPERATOR_CLASS[opr].new(
+          (@options[:port] || @options[:begin_port]),
+          @options[:end_port]
+        )
       else
-        @begin_port
+        fail AclArgumentError, 'Unknown operator'
       end
     end
-  end # class AcePortSpec
-
-  # TCP port number and operator container
-  class AceTcpPortSpec < AcePortSpec
-    # Constructor
-    # @see AcePortSpec#initialize
-    def initialize(opts)
-      super
-      @protocol = :tcp
-    end
-
-    private
-
-    # Convert from port name string to AceTcpProtoSpecBase object
-    # @param [String] name TCP Port Name
-    # @raise [AclArgumentError]
-    # @return [AceTcpProtoSpec]
-    def convert_proto_spec_by_name(name)
-      AceTcpProtoSpec.new(name: name)
-    end
-
-    # Convert from port number integer to AceTcpProtoSpecBase object
-    # @param [Integer] number TCP Port Number
-    # @raise [AclArgumentError]
-    # @return [AceTcpProtoSpec]
-    def convert_proto_spec_by_number(number)
-      AceTcpProtoSpec.new(number: number)
-    end
-  end # class AceTcpPortSpec
-
-  # UDP port number and operator container
-  class AceUdpPortSpec < AcePortSpec
-    # Constructor
-    # @see AcePortSpec#initialize
-    def initialize(opts)
-      super
-      @protocol = :udp
-    end
-
-    private
-
-    # Convert from port name stringto AceUdpProtoSpecBase object
-    # @param [String] name UDP Port Name
-    # @raise [AclArgumentError]
-    # @return [AceUdpProtoSpec]
-    def convert_proto_spec_by_name(name)
-      AceUdpProtoSpec.new(name: name)
-    end
-
-    # Convert from port number integer to AceUdpProtoSpecBase object
-    # @param [Integer] number UDP Port Number
-    # @raise [AclArgumentError]
-    # @return [AceUdpProtoSpec]
-    def convert_proto_spec_by_number(number)
-      AceUdpProtoSpec.new(number: number)
-    end
-  end # class AceUdpPortSpec
+  end
 end # module
 
 ### Local variables:

data/lib/cisco_acl_intp/ace_port_opr.rb

@@ -0,0 +1,251 @@
+# -*- coding: utf-8 -*-
+require 'cisco_acl_intp/ace_port_opr_base'
+
+module CiscoAclIntp
+  # ANY operator class
+  class AcePortOpAny < AceUnaryOpBase
+    # Constructor
+    def initialize(*args)
+      @begin_port = nil
+      @end_port = nil
+      @operator = :any
+    end
+
+    # Specified port-set is contained or not?
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def contains?(other)
+      other.kind_of?(AcePortOperatorBase) # match any conditions
+    end
+
+    # Generate string for Cisco IOS access list
+    # @return [String]
+    def to_s
+      # no need to print tcp/udp ANY in Cisco ACL
+      ''
+    end
+  end
+
+  # SSTRICT-ANY operator class
+  class AcePortOpStrictAny < AcePortOpAny
+    # Constructor
+    def initialize(*args)
+      super
+      @operator = :strict_any
+    end
+
+    # Specified port-set is contained or not?
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def contains?(other)
+      case other
+      when AcePortOpAny, AcePortOpStrictAny
+        true
+      else
+        false
+      end
+    end
+  end
+
+  # EQUAL operator class
+  class AcePortOpEq < AceUnaryOpBase
+    # Constructor
+    def initialize(*args)
+      super
+      @operator = :eq
+    end
+
+    # Specified port-set is contained or not?
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def contains?(other)
+      case other
+      when AcePortOpEq
+        other.port == @begin_port
+      else
+        contains_default(other)
+      end
+    end
+  end
+
+  # NOT_EQUAL operator class
+  class AcePortOpNeq < AceUnaryOpBase
+    # Constructor
+    def initialize(*args)
+      super
+      @operator = :neq
+    end
+
+    private
+
+    # Operate EQUAL containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_eq(other)
+      other.port != @begin_port
+    end
+
+    # Operate NOT_EQUAL containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_neq(other)
+      other.port == @begin_port
+    end
+
+    # Operate LOWER_THAN containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_lt(other)
+      other.port <= @begin_port
+    end
+
+    # Operate GREATER_THAN containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_gt(other)
+      @begin_port <= other.port
+    end
+
+    # Operate RANGE containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_range(other)
+      other.end_port < @begin_port || @begin_port < other.begin_port
+    end
+  end
+
+  # LOWER_THAN operator class
+  class AcePortOpLt < AceUnaryOpBase
+    # Constructor
+    def initialize(*args)
+      super
+      @operator = :lt
+    end
+
+    private
+
+    # Operate EQUAL containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_eq(other)
+      other.port < @begin_port
+    end
+
+    # Operate NOT_EQUAL containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_neq(other)
+      other.port.max? && @begin_port.max?
+    end
+
+    # Operate LOWER_THAN containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_lt(other)
+      other.port <= @begin_port
+    end
+
+    # Operate RANGE containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_range(other)
+      other.end_port < @begin_port
+    end
+  end
+
+  # GREATER_THAN operator class
+  class AcePortOpGt < AceUnaryOpBase
+    # Constructor
+    def initialize(*args)
+      super
+      @operator = :gt
+    end
+
+    private
+
+    # Operate EQUAL containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_eq(other)
+      @begin_port < other.port
+    end
+
+    # Operate NOT_EQUAL containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_neq(other)
+      @begin_port.min? && other.port.min?
+    end
+
+    # Operate GREATER_THAN containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_gt(other)
+      @begin_port <= other.port
+    end
+
+    # Operate RANGE containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_range(other)
+      @begin_port < other.begin_port
+    end
+  end
+
+  # RANGE operator class
+  class AcePortOpRange < AcePortOperatorBase
+    # Constructor
+    def initialize(*args)
+      super
+      unless @begin_port < @end_port
+        fail AclArgumentError, 'Invalid port sequence'
+      end
+      @operator = :range
+    end
+
+    private
+
+    # Operate EQUAL containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_eq(other)
+      @begin_port <= other.port && other.port <= @end_port
+    end
+
+    # Operate NOT_EQUAL containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_neq(other)
+      @begin_port.min? && @end_port.max? &&
+        (other.port.min? || other.port.max?)
+    end
+
+    # Operate LOWER_THAN containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_lt(other)
+      @begin_port.min? && other.port < @end_port
+    end
+
+    # Operate GREATER_THAN containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_gt(other)
+      @begin_port < other.port && @end_port.max?
+    end
+
+    # Operate RANGE containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_range(other)
+      @begin_port <= other.begin_port &&
+        other.end_port <= @end_port
+    end
+  end
+end # module
+
+### Local variables:
+### mode: Ruby
+### coding: utf-8-unix
+### indent-tabs-mode: nil
+### End:

data/lib/cisco_acl_intp/ace_port_opr_base.rb

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+require 'cisco_acl_intp/acl_base'
+
+module CiscoAclIntp
+  # TCP/UDP Port Set Operator Class
+  class AcePortOperatorBase < AclContainerBase
+    # @return
+    attr_reader :operator
+
+    # @param [AceProtoSpecBase] value Port No. (single/lower)
+    # @return [AceProtoSpecBase]
+    attr_reader :begin_port
+    # alias for unary operator
+    alias_method :port, :begin_port
+
+    # @param [AceProtoSpecBase] value Port No. (higher)
+    # @return [AceProtoSpecBase]
+    attr_reader :end_port
+
+    # Constructor
+    # @param [AceProtoSpecBase] begin_port Begin port object.
+    # @param [AceProtoSpecBase] end_port End port object.
+    # @raise [AclArgumentError]
+    def initialize(begin_port, end_port = nil)
+      @operator = :any # default
+      @begin_port = begin_port
+      @end_port = end_port
+    end
+
+    # Check equality
+    # @param [AceProtoSpecBase] other RHS object.
+    # @return [Boolean]
+    def ==(other)
+      @operator == other.operator &&
+        @begin_port == other.begin_port &&
+        @end_port == other.end_port
+    end
+
+    # Generate string for Cisco IOS access list
+    # @return [String]
+    def to_s
+      tag_port(
+        clean_acl_string(
+          format('%s %s %s', @operator, @begin_port, @end_port)
+        )
+      )
+    end
+
+    # Specified port-set is contained or not?
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def contains?(other)
+      case other
+      when AcePortOpEq
+        compare_eq(other)
+      when AcePortOpNeq
+        compare_neq(other)
+      when AcePortOpLt
+        compare_lt(other)
+      when AcePortOpGt
+        compare_gt(other)
+      when AcePortOpRange
+        compare_range(other)
+      else
+        contains_default(other)
+      end
+    end
+
+    private
+
+    # Operate EQUAL containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_eq(other)
+      false
+    end
+
+    # Operate NOT_EQUAL containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_neq(other)
+      false
+    end
+
+    # Operate LOWER_THAN containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_lt(other)
+      false
+    end
+
+    # Operate GREATER_THAN containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_gt(other)
+      false
+    end
+
+    # Operate RANGE containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def compare_range(other)
+      false
+    end
+
+    # Operate *ANY containing check
+    # @param [AcePortOperator] other Another operator
+    # @return [Boolean]
+    def contains_default(other)
+      case other
+      when AcePortOpAny
+        true
+      when AcePortOpStrictAny
+        false
+      else
+        false
+      end
+    end
+  end
+
+  # Unary operator base class
+  class AceUnaryOpBase < AcePortOperatorBase
+    # Constructor
+    def initialize(*args)
+      super
+      if @begin_port.nil?
+        fail AclArgumentError, 'Port did not specified in unary operator'
+      end
+      @end_port = nil
+    end
+  end
+end # module
+
+### Local variables:
+### mode: Ruby
+### coding: utf-8-unix
+### indent-tabs-mode: nil
+### End: