netbox-client-ruby 0.0.1

data/lib/netbox_client_ruby/connection.rb

@@ -0,0 +1,33 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'faraday/detailed_logger'
+require 'netbox_client_ruby/error/local_error'
+
+module NetboxClientRuby
+  class Connection
+    def self.new
+      build_faraday
+    end
+
+    def self.headers
+      headers = {}
+      netbox_auth_config = NetboxClientRuby.config.netbox.auth
+
+      raise LocalError, 'The authorization_token has not been configured.' unless netbox_auth_config.token
+
+      headers['Authorization'] = "Token #{netbox_auth_config.token}"
+      headers
+    end
+
+    private_class_method def self.build_faraday
+      config = NetboxClientRuby.config
+      Faraday.new(url: config.netbox.api_base_url, headers: headers) do |faraday|
+        faraday.request :json
+        faraday.response config.faraday.logger if config.faraday.logger
+        faraday.response :json, content_type: /\bjson$/
+        faraday.adapter config.faraday.adapter || Faraday.default_adapter
+        faraday.options.merge NetboxClientRuby.config.faraday.request_options
+      end
+    end
+  end
+end

data/lib/netbox_client_ruby/entities.rb

@@ -0,0 +1,200 @@
+require 'netbox_client_ruby/entity'
+require 'netbox_client_ruby/error/local_error'
+require 'pry'
+
+module NetboxClientRuby
+  module Entities
+    include NetboxClientRuby::Communication
+
+    def self.included(other_klass)
+      other_klass.extend ClassMethods
+    end
+
+    module ClassMethods
+      def self.extended(other_klass)
+        @other_klass = other_klass
+      end
+
+      def data_key(key = 'data')
+        @data_key ||= key
+      end
+
+      def count_key(key = 'count')
+        @count_key ||= key
+      end
+
+      def limit(limit = nil)
+        return @limit if @limit
+
+        @limit = limit || NetboxClientRuby.config.netbox.pagination.default_limit
+
+        if @limit.nil?
+          raise ArgumentError,
+                "Whether 'limit' nor 'default_limit' are defined."
+        end
+
+        check_limit @limit
+
+        @limit
+      end
+
+      def check_limit(limit)
+        max_limit = NetboxClientRuby.config.netbox.pagination.max_limit
+        if limit.nil?
+          raise ArgumentError,
+                "'limit' can not be nil."
+        elsif !limit.is_a?(Numeric)
+          raise ArgumentError,
+                "The limit '#{limit}' is not numeric but it has to be."
+        elsif !limit.integer?
+          raise ArgumentError,
+                "The limit '#{limit}' is not integer but it has to be."
+        elsif limit.negative?
+          raise ArgumentError,
+                "The limit '#{limit}' is below zero, but it should be zero or bigger."
+        elsif limit > max_limit
+          raise ArgumentError,
+                "The limit '#{limit}' is bigger than the configured limit value ('#{max_limit}')."
+        end
+      end
+
+      def entity_creator(creator = nil)
+        return @entity_creator if @entity_creator
+
+        raise ArgumentError, '"entity_creator" has not been defined.' unless creator
+
+        @entity_creator = creator
+      end
+
+      def path(path = nil)
+        return @path if @path
+
+        raise ArgumentError, '"path" has not been defined.' unless path
+
+        @path = path
+      end
+    end
+
+    def filter(filter)
+      raise ArgumentError, '"filter" expects a hash' unless filter.is_a? Hash
+
+      @filter = filter
+      reset
+      self
+    end
+
+    def all
+      @instance_limit = NetboxClientRuby.config.netbox.pagination.max_limit
+      reset
+      self
+    end
+
+    def limit(limit)
+      self.class.check_limit limit unless limit.nil?
+
+      @instance_limit = limit
+      reset
+      self
+    end
+
+    def offset(offset)
+      raise ArgumentError, "The offset '#{offset}' is not numeric." unless offset.is_a? Numeric
+      raise ArgumentError, "The offset '#{offset}' must not be negative." if offset.negative?
+
+      @offset = offset
+      reset
+      self
+    end
+
+    def page(page)
+      raise ArgumentError, "The offset '#{page}' is not numeric but has to be." unless page.is_a? Numeric
+      raise ArgumentError, "The offset '#{page}' must be integer but isn't." unless page.integer?
+      raise ArgumentError, "The offset '#{page}' must not be negative but is." if page.negative?
+
+      limit = @instance_limit || self.class.limit
+      offset(limit * page)
+    end
+
+    def [](index)
+      return nil if length <= index
+
+      as_entity raw_data_array[index]
+    end
+
+    def as_array
+      raw_data_array.map { |raw_entity| as_entity raw_entity }
+    end
+
+    ##
+    # The number of entities that have been fetched
+    def length
+      raw_data_array.length
+    end
+
+    ##
+    # The total number of available entities for that query
+    def total
+      data[self.class.count_key]
+    end
+
+    def reload
+      @data = get
+      self
+    end
+
+    def raw_data!
+      data
+    end
+
+    alias get! reload
+    alias size length
+    alias count total
+
+    private
+
+    def reset
+      @data = nil
+    end
+
+    def raw_data_array
+      data[self.class.data_key] || []
+    end
+
+    def data
+      @data ||= get
+    end
+
+    def get
+      response connection.get path_with_parameters
+    end
+
+    def path_with_parameters
+      self.class.path + path_parameters
+    end
+
+    def path_parameters
+      params = []
+
+      params << @filter
+      params << { limit: @instance_limit || self.class.limit }
+      params << { offset: @offset } if @offset
+
+      join_path_parameters(params)
+    end
+
+    def join_path_parameters(params)
+      return '' if params.empty?
+
+      '?' + params.compact.map do |param_obj|
+        URI.encode_www_form param_obj
+      end.join('&')
+    end
+
+    def as_entity(raw_entity)
+      entity_creator_method = method self.class.entity_creator
+      entity = entity_creator_method.call raw_entity
+      entity.data = raw_entity
+      entity
+    end
+  end
+end

data/lib/netbox_client_ruby/entity.rb

@@ -0,0 +1,345 @@
+require 'netbox_client_ruby/communication'
+require 'netbox_client_ruby/error/local_error'
+
+module NetboxClientRuby
+  module Entity
+    include NetboxClientRuby::Communication
+
+    def self.included(other_klass)
+      other_klass.extend ClassMethods
+    end
+
+    module ClassMethods
+      ##
+      # Expects ids in the following format:
+      #   id 'an_id_field'
+      #   id :an_id_field
+      #   id 'an_id_field', 'another_id_field'
+      #   id :an_id_field, :another_id_field
+      #   id an_id_field: 'id_field_in_data'
+      #   id an_id_field: :id_field_in_data
+      #   id 'an_id_field' => :id_field_in_data
+      #   id 'an_id_field' => 'id_field_in_data'
+      #   id an_id_field: 'id_field_in_data', :another_id_field: 'id_field2_in_data'
+      #
+      def id(*fields)
+        return @id_fields if @id_fields
+
+        raise ArgumentError, "No 'id' was defined, but one is expected." if fields.empty?
+
+        @id_fields = {}
+        if fields.first.is_a?(Hash)
+          fields.first.each { |key, value| @id_fields[key.to_s] = value.to_s }
+        else
+          fields.map(&:to_s).each do |field|
+            field_as_string = field.to_s
+            @id_fields[field_as_string] = field_as_string
+          end
+        end
+
+        @id_fields.keys.each do |field|
+          define_method(field) { instance_variable_get "@#{field}" }
+        end
+
+        @id_fields
+      end
+
+      def readonly_fields(*fields)
+        return @readonly_fields if @readonly_fields
+
+        @readonly_fields = fields.map(&:to_s)
+      end
+
+      def deletable(deletable = false)
+        @deletable ||= deletable
+      end
+
+      def path(path = nil)
+        @path ||= path
+
+        return @path if @path
+
+        raise ArgumentError, "No argument to 'path' was given."
+      end
+
+      def creation_path(creation_path = nil)
+        @creation_path ||= creation_path
+
+        return @creation_path if @creation_path
+
+        raise ArgumentError, "No argument to 'creation_path' was given."
+      end
+
+      # allowed values:
+      # <code>
+      # object_fields :field_a, :field_b, :field_c, 'fieldname_as_string'
+      # # next is ame as previous
+      # object_fields field_a: nil, field_b: nil, field_c: nil, 'fieldname_as_string': nil
+      # # next defines the types of the objects
+      # object_fields field_a: Klass, field_b: proc { |data| Klass.new data }, field_c: nil, 'fieldname_as_string'
+      # </code>
+      def object_fields(*fields_to_class_map)
+        return @object_fields if @object_fields
+
+        if fields_to_class_map.nil? || fields_to_class_map.empty?
+          @object_fields = {}
+        else
+          fields_map = sanitize_mapping(fields_to_class_map)
+          @object_fields = fields_map
+        end
+      end
+
+      def sanitize_mapping(fields_to_class_map)
+        fields_map = {}
+        fields_to_class_map.each do |field_definition|
+          if field_definition.is_a?(Hash)
+            fields_to_class_map[0].each do |field, klass_or_proc|
+              fields_map[field.to_s] = klass_or_proc
+            end
+          else
+            fields_map[field_definition.to_s] = nil
+          end
+        end
+        fields_map
+      end
+    end
+
+    def initialize(given_ids = nil)
+      return self if given_ids.nil?
+
+      if id_fields.count == 1 && !given_ids.is_a?(Hash)
+        instance_variable_set("@#{id_fields.keys.first}", given_ids)
+        return self
+      end
+
+      check_given_ids(given_ids)
+
+      given_ids.each { |id_field, id_value| instance_variable_set "@#{id_field}", id_value }
+
+      self
+    end
+
+    def revert
+      dirty_data.clear
+      self
+    end
+
+    def reload
+      @data = get
+      revert
+      self
+    end
+
+    def save
+      return post unless ids_set?
+      patch
+    end
+
+    def create(raw_data)
+      raise LocalError, "Can't 'create', this object already exists" if ids_set?
+
+      @dirty_data = raw_data
+      post
+    end
+
+    def delete
+      raise NetboxClientRuby::LocalError, "Can't delete unless deletable=true" unless deletable
+      return self if @deleted
+
+      @data = response connection.delete path
+      @deleted = true
+      revert
+      self
+    end
+
+    def update(updated_fields)
+      checked_updated_fields = {}
+      updated_fields.each do |key, values|
+        s_key = key.to_s
+
+        checked_updated_fields[s_key] = values unless readonly_fields.include? s_key
+      end
+
+      dirty_data.merge! checked_updated_fields
+      patch
+    end
+
+    def raw_data!
+      data
+    end
+
+    def [](name)
+      s_name = name.to_s
+      dirty_data[s_name] || data[s_name]
+    end
+
+    def []=(name, value)
+      dirty_data[name.to_s] = value
+    end
+
+    def method_missing(name_as_symbol, *args, &block)
+      name = name_as_symbol.to_s
+
+      if name.end_with?('=')
+        is_readonly_field = readonly_fields.include?(name[0..-2])
+        is_instance_variable = instance_variables.include?("@#{name[0..-2]}".to_sym)
+        not_this_classes_business = is_readonly_field || is_instance_variable
+
+        if not_this_classes_business
+          super
+        else
+          dirty_data[name[0..-2]] = args[0]
+          return args[0]
+        end
+      end
+
+      return objectify(name, object_fields[name]) if object_fields.keys.include? name
+
+      return dirty_data[name] if dirty_data.keys.include? name
+      return data[name] if data.is_a?(Hash) && data.keys.include?(name)
+
+      super
+    end
+
+    def respond_to_missing?(name_as_symbol, *args)
+      name = name_as_symbol.to_s
+
+      return false if name.end_with?('=') && readonly_fields.include?(name[0..-2])
+      return false if name.end_with?('=') && instance_variables.include?(name[0..-2])
+
+      return true if object_fields.keys.include? name
+
+      return true if dirty_data.keys.include? name
+      return true if data.is_a?(Hash) && data.keys.include?(name)
+
+      super
+    end
+
+    ##
+    # :internal: Used to pre-populate an entity
+    def data=(data)
+      @data = data
+    end
+
+    alias get! reload
+    alias remove delete
+
+    private
+
+    def post
+      return self if dirty_data.empty?
+
+      @data = response connection.post creation_path, dirty_data
+      extract_ids
+      revert
+      self
+    end
+
+    def patch
+      return self if dirty_data.empty?
+
+      @data ||= {}
+      response_data = response connection.patch(path, dirty_data)
+      @data.merge! response_data
+      revert
+      self
+    end
+
+    def check_given_ids(given_ids)
+      if !given_ids.is_a? Hash
+        raise ArgumentError, "'#{self.class}.new' expects the argument to be a Hash when multiple ids are defined"
+      elsif given_ids.empty?
+        raise ArgumentError, "'#{self.class}.new' expects a the argument to not be empty."
+      end
+
+      missing_ids = id_fields.keys - given_ids.keys.map(&:to_s)
+
+      unless missing_ids.empty?
+        raise ArgumentError,
+              "'#{self.class}.new' expects a value for all defined IDs. The following values are missing: '#{missing_ids.join(', ')}'"
+      end
+    end
+
+    def data
+      @data ||= get
+    end
+
+    def get
+      response connection.get path unless @deleted
+    end
+
+    def readonly_fields
+      self.class.readonly_fields
+    end
+
+    def deletable
+      self.class.deletable
+    end
+
+    def object_fields
+      self.class.object_fields
+    end
+
+    def data_to_obj(raw_data, klass_or_proc = nil)
+      if klass_or_proc.nil?
+        hash_to_object raw_data
+      elsif klass_or_proc.is_a? Proc
+        klass_or_proc.call raw_data
+      else
+        klass_or_proc.new raw_data
+      end
+    end
+
+    def objectify(name, klass_or_proc = nil)
+      raw_data = data[name]
+      
+      return nil if raw_data.nil?
+
+      return data_to_obj(raw_data, klass_or_proc) unless raw_data.is_a? Array
+
+      data[name].map do |raw_data_entry|
+        data_to_obj(raw_data_entry, klass_or_proc)
+      end
+    end
+
+    def creation_path
+      @creation_path ||= replace_path_variables_in self.class.creation_path
+    end
+
+    def path
+      @path ||= replace_path_variables_in self.class.path
+    end
+
+    def replace_path_variables_in(path)
+      interpreted_path = path.clone
+      path.scan(/:([a-zA-Z_][a-zA-Z0-9_]+[!?=]?)/) do |match, *|
+        path_variable_value = send(match)
+        return interpreted_path.gsub! ":#{match}", path_variable_value.to_s unless path_variable_value.nil?
+        raise LocalError, "Received 'nil' while replacing ':#{match}' in '#{path}' with a value."
+      end
+      interpreted_path
+    end
+
+    def dirty_data
+      @dirty_data ||= {}
+    end
+
+    def id_fields
+      self.class.id
+    end
+
+    def extract_ids
+      id_fields.each do |id_attr, id_field|
+        unless data.key?(id_field)
+          raise LocalError, "Can't find the id field '#{id_field}' in the received data."
+        end
+
+        instance_variable_set("@#{id_attr}", data[id_field])
+      end
+    end
+
+    def ids_set?
+      id_fields.map { |id_attr, _| instance_variable_get("@#{id_attr}") }.all?
+    end
+  end
+end