acirb 1.1.2.1 → 1.1.2.2

data/lib/mo.rb

@@ -1,260 +0,0 @@
-require 'restclient'
-require 'rexml/document'
-require 'json'
-
-# rubocop:disable ClassLength
-module ACIrb
-  # A generic managed object class
-  class MO
-    # Class variable properties
-    class << self
-      # for class variables
-      attr_reader :prefix, :class_name, :child_classes, :props,
-                  :naming_props, :prefixes, :ruby_class, :containers,
-                  :read_only
-    end
-
-    # for instance variables
-    attr_reader :children, :attributes
-    attr_accessor :parent, :dirty_props
-
-    # Internal: Returns class prefixes
-    def prefixes
-      self.class.prefixes
-    end
-
-    # Internal: Returns child classes
-    def child_classes
-      self.class.child_classes
-    end
-
-    # Internal: Returns containiner classes
-    def containers
-      self.class.containers
-    end
-
-    # Internal: Returns naming properties
-    def naming_props
-      self.class.naming_props
-    end
-
-    # Internal: Returns class properties
-    def props
-      self.class.props
-    end
-
-    # Internal: Returns object class name in APIC package.class notation
-    def class_name
-      self.class.class_name
-    end
-
-    # Internal: Returns class name as ruby package notation
-    def ruby_class
-      self.class.ruby_class
-    end
-
-    # Interal: Returns boolean for if this class is read only
-    def read_only
-      self.class.read_only
-    end
-
-    def initialize(create_parent, create_options = {})
-      # always mark dirty unless otherwise specified
-      if create_options[:mark_dirty] == false
-        mark_dirty = false
-      else
-        mark_dirty = true
-      end
-      create_options.delete(:mark_dirty)
-
-      @attributes = {}
-      @dirty_props = []
-      props.each do |prop, _flags|
-        @attributes[prop.to_s] = ''
-      end
-      @children = []
-
-      if create_parent.nil?
-        @parent = nil
-      else
-        @parent = create_parent
-        @parent.add_child(self)
-      end
-
-      # for performance reasons, do not use set_prop here
-      # and build the dn string after all attributes are set
-      create_options.each do |k, v|
-        flags = props[k.to_s]
-        @attributes[k.to_s] = v.to_s
-        @dirty_props.push(k.to_s) if mark_dirty
-      end
-      @attributes['dn'] = build_dn
-      @attributes['rn'] = rn
-    end
-
-    # Internal: Adds another MO object as a child to this class
-    def add_child(child)
-      unless child.containers.include?(ruby_class)
-        fail child.class.to_s + ' cannot be child of ' + self.class.to_s
-      end
-      @children.each do |mo|
-        return nil if mo.dn == child.dn
-      end
-      @children.push(child)
-      child.parent = self
-    end
-
-    def set_prop(key, val)
-      key = key.to_s
-      val = val.to_s
-
-      return if key == 'dn' || key == 'rn'
-
-      @attributes[key] = val
-      @dirty_props.push(key)
-
-      if naming_props.include? key
-        dn_str = build_dn
-        @attributes['dn'] = dn_str
-        @attributes['rn'] = rn
-      end
-    end
-
-    def root
-      p = self
-      p = p.parent until p.parent.nil?
-      p
-    end
-
-    def get_attributes_to_include
-      incl_attr = {}
-      @attributes.each do |key, value|
-        if props[key.to_s]['isDn'] == true || props[key.to_s]['isRn'] == true || @dirty_props.include?(key) || naming_props.include?(key)
-          incl_attr[key.to_s] = value
-        end
-      end
-      incl_attr
-    end
-
-    def get_children_to_include
-      incl_children = []
-      @children.each do |child|
-        incl_children.push(child) if child.read_only == false
-      end
-      incl_children
-    end
-
-    def to_xml
-      # TODO: Use nokogiri here
-      #   https://github.com/sparklemotion/nokogiri/wiki/Cheat-sheet
-      x = REXML::Element.new mo_type.to_s
-
-      get_attributes_to_include.each do |key, value|
-        x.attributes[key.to_s] = value
-      end
-
-      get_children_to_include.each do |child|
-        x.add_element(child.to_xml)
-      end
-      x
-    end
-
-    def to_hash
-      h = {}
-      h[mo_type.to_s] = {}
-      h[mo_type.to_s]['attributes'] = {}
-      get_attributes_to_include.each do |key, value|
-        h[mo_type.to_s]['attributes'][key.to_s] = value
-      end
-      h[mo_type.to_s]['attributes']['dn'] = dn
-      h[mo_type.to_s]['children'] = [] if children.length > 0
-      get_children_to_include.each do |child|
-        h[mo_type.to_s]['children'].push(child.to_hash)
-      end
-      h
-    end
-
-    def to_json
-      JSON.dump(to_hash)
-    end
-
-    def create(restclient)
-      self.status = 'created,modified'
-      restclient.post(data: self,
-                      url: "/api/mo/#{dn}.#{restclient.format}")
-      @dirty_props = []
-    end
-
-    def destroy(restclient)
-      self.status = 'deleted'
-      restclient.post(data: self,
-                      url: "/api/mo/#{dn}.#{restclient.format}")
-      @dirty_props = []
-    end
-
-    def exists(restclient, recurse = false)
-      options = {}
-      options[:subtree] = 'full' if recurse
-      if restclient.lookupByDn(dn, options)
-        if recurse == true
-          children.each do |child|
-            unless child.exists(restclient, recurse = true)
-              return false
-            end
-          end
-        end
-        return true
-      else
-        return false
-      end
-    end
-
-    def build_dn
-      if @parent.nil?
-        return rn
-      else
-        parent_dn = '' << @parent.dn
-        if parent_dn == ''
-          return rn
-        else
-          parent_dn << '/'
-          parent_dn << rn
-          return parent_dn
-        end
-      end
-    end
-
-    def mo_type
-      self.class.class_name.delete('.')
-    end
-
-    def to_s
-      def hash_to_table(h)
-        len = h.keys.map(&:length).max
-        ret = []
-        h.each do |k, v|
-          ret.push(('%' + len.to_s + 's: %s') % [k.to_s, v.to_s])
-        end
-        ret
-      end
-      header_table = hash_to_table(
-        'Class' => class_name
-      )
-      attribute_table = hash_to_table(attributes)
-      header_table.push(attribute_table)
-      header_table.join("\n")
-    end
-
-    def method_missing(name, *args, &block)
-      lookup_name = name.to_s
-      return @attributes[lookup_name] if @attributes.key? lookup_name
-      return set_prop(lookup_name.chomp('='), args[0]) if @attributes.key? lookup_name.chomp('=')
-      child_matches = []
-      @children.each do |child|
-        child_matches.push(child) if child.class.prefix.sub('-', '') == lookup_name
-      end
-      return child_matches if child_matches.length > 0
-      super
-    end
-  end
-end

data/lib/naming.rb

@@ -1,124 +0,0 @@
-module ACIrb
-  class Naming
-    def self.split_outside_brackets(dn_str, splitChar)
-      depth = 0
-      place = 0
-      last_split = 0
-      pieces = []
-      while place < dn_str.length
-        c = dn_str[place]
-        if c == '['
-          depth += 1
-        elsif c == ']'
-          depth -= 1
-        end
-        if depth == 0 && c == splitChar && place != 0
-          pieces.push(dn_str[last_split..place])
-          last_split = place + 1
-        end
-        place += 1
-      end
-      pieces.push(dn_str[last_split..place - 1]) if place != last_split
-
-      pieces
-    end
-
-    def self.strip_last_delimiter(str, delim)
-      if str[-1] == delim
-        return str[0..-2]
-      else
-        return str
-      end
-    end
-
-    def self.strip_outer_brackets(str)
-      if str[0] == '[' && str[-1] == ']'
-        return str[1..-2]
-      else
-        return str
-      end
-    end
-
-    def self.split_dn_str(dn_str)
-      rns = []
-      split_outside_brackets(dn_str, '/').each do |rn|
-        rns.push(strip_last_delimiter(rn, '/'))
-      end
-      rns
-    end
-
-    def self.split_rn_str(rn_str, delims)
-      rn_pieces = []
-      delims.each_with_index do |(delim, _has_prop), index|
-        begin_delim = rn_str.split(delim)
-
-        if index == delims.length - 1
-          name_prop = begin_delim[1]
-        else
-          rn_str = begin_delim[1]
-          end_delim = rn_str.split(delims[index + 1][0])
-          name_prop = end_delim[0]
-        end
-
-        rn_pieces.push(delim)
-        rn_pieces.push(name_prop)
-      end
-      rn_pieces
-    end
-
-    def self.get_mo_from_dn(dn_str)
-      rns = split_dn_str(dn_str)
-      mo = ACIrb::TopRoot.new(nil)
-      rns.each do |rn|
-        mo = get_mo_from_rn(mo, rn)
-      end
-      mo
-    end
-
-    def self.get_mo_from_rn(parent_mo, rn_str)
-      mo = get_class_from_child_prefix(parent_mo, rn_str).new(parent_mo)
-      return mo if mo.naming_props.length == 0
-      rn_pieces = split_rn_str(rn_str, mo.prefixes)
-      rn_values = rn_pieces.values_at(*(1..rn_pieces.length - 1).step(2))
-      mo.naming_props.each_with_index do |prop_name, index|
-        prop_val = rn_values[index]
-        mo.set_prop(prop_name.to_s, strip_outer_brackets(prop_val))
-      end
-      mo
-    end
-
-    def self.match_prefix_in_list(rn_str, prefix_list)
-      matches = false
-      prefix_match = ''
-      prefix_list.each do |prefix|
-        if rn_str.start_with?(prefix)
-          matches = true
-          prefix_match = prefix
-          break
-        end
-      end
-
-      return prefix_match if matches
-
-      nil
-    end
-
-    def self.get_class_from_child_prefix(parent_mo, rn_str)
-      prefix_to_class = {}
-      parent_mo.child_classes.each do |c|
-        cls = ACIrb.const_get(c)
-        prefix_to_class[cls.prefix] = cls
-      end
-
-      lpm = prefix_to_class.keys.sort_by { |x| -1 * x.length }
-      prefix_match = match_prefix_in_list(rn_str, lpm)
-
-      if prefix_match
-        return prefix_to_class[prefix_match]
-      else
-        fail 'Unknown child prefix ' + rn_str + ' in container class ' +
-          parent_mo.class.to_s
-      end
-    end
-  end
-end

data/lib/version.rb

@@ -1,3 +0,0 @@
-module ACIrb
-  VERSION = '1.1.2.1'
-end