kodi_client 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fea7dad06fe723225e4d8bf268db09490af87c98a74f653e5966f170d1156fd
-  data.tar.gz: a4d8a3dfcac1a85abbf1c073b0c2f6016de9de9d07249eabc5067fe47c829727
+  metadata.gz: 7bbe8ae31b1c2f5092c6e6fa02a4641d3a73393dcedb44cd08e75f977b85b19b
+  data.tar.gz: 2d5362b89b5ef4e02542a2fcf9e548a8d33f38575496bbcd48a2b40c1c378003
 SHA512:
-  metadata.gz: 031fcbe6dc03750fa90d3b8d395f903082d6b2b8586f3fe49ff3d9d5ca3375501e2b8e34305808399026de10bd62a5cfc00bf3ad5fc505cb5043e47ba2cdc85f
-  data.tar.gz: 6e9622971b0e8737130feddefca5ac49a8efd4073dd4ec9719b524c2cb7ba3781e915322a03bd1ffac63fe4ab48b3ed1428a83135a69223add9a041b8ff1288d
+  metadata.gz: 89796e76db1800a22e165a2bec14b2c3365318f87d7f57cf2861cdf2646ff0ca1e1108b47f0399782f4491fa9c2604e8fadec6f83f878b15e420bd74901510e8
+  data.tar.gz: f42bf33a0651081ec388e7bf5142d5284e00cd5d8e8d0b07d5766c05ea18197f7c523b97642fe993e6e789576c677945b1949764d592bdecab0d635d661d7edc

data/.rubocop.yml

@@ -12,5 +12,7 @@ Metrics/MethodLength:
   Enabled: false
 Metrics/PerceivedComplexity:
   Enabled: false
+Metrics/ModuleLength:
+  Enabled: false
 Style/OptionalBooleanParameter:
   Enabled: false

data/README.md

@@ -5,6 +5,7 @@ RubyKodiClient is a work-in-progress client for [Kodi JSON API v12](https://kodi
 Currently implemented are the following Methods:
 * Addons
 * Application
+* AudioLibrary
 * Favourites
 * Files
 * GUI

data/kodi_client.gemspec

@@ -2,12 +2,12 @@
 
 Gem::Specification.new do |spec|
   spec.name          = 'kodi_client'
-  spec.version       = '0.6.1'
+  spec.version       = '0.7.0'
   spec.authors       = ['Christian Feier']
   spec.email         = ['christian.feier@gmail.com']
 
   spec.summary       = 'A work-in-progress client for Kodi JSON API v2.'
-  spec.description   = 'A client for the Kodi JSON API v12, currently implemented methods are Addons, Application, '\
+  spec.description   = 'A client for the Kodi JSON API v12, currently implemented methods are Addons, Application, AudioLibrary '\
                        'Favourites, Files, GUI, Input, Player, Profiles and System (more will be added with the time). '\
                        'For more information how to use it and how to activate Remote Control in Kodi, '\
                        'please check the github page https://github.com/cfe86/RubyKodiClient'

data/lib/kodi_client/extensions/chainable.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module KodiClient
+  module Extensions
+    # Offers methods like connect, auth and tls to be chained together
+    module Chainable
+
+      attr_accessor :options, :client
+
+      # Creates a new Client instance and sets the given ip and port to connect to it
+      # @param ip [String] the ip to use
+      # @param port [Integer] the port to connect to
+      # @raise [ArgumentError] thrown if ip or port is nil
+      # @return [Client] the created client
+      def connect(ip, port)
+        throw ArgumentError('ip or port can\'t be nil.') if ip.nil? || port.nil?
+        @client = KodiClient::Client.new
+        merge_options(->(options) { options.with_connection(ip, port) })
+      end
+
+      # sets username and password if required
+      # @param username [String] the username
+      # @param password [String] the password
+      # @return [Client] the existing, or if not existed, a new created client
+      def auth(username, password)
+        throw ArgumentError('username or password can\'t be nil.') if username.nil? || password.nil?
+        merge_options(->(options) { options.with_auth(username, password) })
+      end
+
+      # enables/disables the use of TLS
+      # @param enabled [Boolean] true to enable it, false to disable
+      # @return [Client] the existing, or if not existed, a new created client
+      def use_tls(enabled: true)
+        merge_options(->(options) { options.with_tls(enabled) })
+      end
+
+      # merges the existing options with the new options
+      # @param [Proc] set_command so command to execute on the existing options to merge them
+      # @return [Client] the existing, or if not existed, a new created client
+      def merge_options(set_command)
+        client = def_client
+        options = def_options
+        set_command.call(options)
+        client.apply_options_to_methods(options)
+        client
+      end
+
+      # Creates a new, or if one already exists, returns the existing client
+      # @return [Client] the new or existing client
+      def def_client
+        if @client.nil?
+          @client = KodiClient::Client.new
+          @client.client = @client
+        end
+        @client
+      end
+
+      # Creates a new, or if one already exists, returns the existing Options
+      # @return [KodiOptions] the new or existing Options
+      def def_options
+        if @options.nil?
+          @options ||= KodiClient::KodiOptions.new
+          @client.options = @options
+        end
+        @options
+      end
+
+      private :def_client, :def_options, :merge_options
+    end
+  end
+end

data/lib/kodi_client/extensions/comparable.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module KodiClient
+  module Extensions
+    # offers compare methods
+    module Comparable
+
+      # compares the instance variables of 2 objects for equality
+      # @param obj1 object 1
+      # @param obj2 object 2
+      # @return [Boolean] true if both instance variables are the same, else false
+      def compare(obj1, obj2)
+        is_same = true
+        obj1.instance_variables.each do |it|
+          is_same = false if obj1.instance_variable_get(it) != obj2.instance_variable_get(it)
+        end
+
+        is_same
+      end
+
+      # compares all Comparables using the defined compare method
+      # @param other [Object] the object to compare with
+      # @return [Boolean] true if equal, else false
+      def ==(other)
+        compare(self, other)
+      end
+    end
+  end
+end

data/lib/kodi_client/extensions/creatable.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module KodiClient
+  module Extensions
+    # creates a create and create_list method by hash
+    module Creatable
+
+      # sets the fields to fetch from the given hash for the #create method. This is optional and only to use, if
+      # more fields should be fetched than are provided using attr_reader
+      # @param [Array<String>] fields the fields given as a string array
+      def fields_to_map(fields)
+        @fields_to_map = fields
+      end
+
+      # defines mappings in case an attribute in the hash is not primitive and requires further processing. The argument
+      # is an Array of Arrays. Each array contains ['field_name', [type_to_map_to], [opt if field is a list]]
+      # @param args [Array<Array>] mappings. Example mapping ['art', Media::ArtWork, true], in this case
+      # Media::ArtWork.create_list will be called
+      def type_mapping(*args)
+        return if args.nil?
+
+        @type_mapping = {}
+        args.map { |it| @type_mapping[it[0]] = Creatable::CreateMap.new(it[1], it[2].nil? ? false : it[2]) }
+      end
+
+      # if @type_mapping is nil, it tries to fetch the mapping from here instead
+      # @return [Hash<String, CreateMap>] an hash containing all the mappings
+      def lazy_type_mapping
+        {}
+      end
+
+      # expects the given hash is a list of hashes and calls #create on each element
+      # @param [Array<Hash>] hash given list of hashes
+      # @return [Array] empty if hash is nil, otherwise array containing the elements
+      def create_list(hash)
+        hash.nil? ? [] : hash.map { |it| create(it) }.reject(&:nil?)
+      end
+
+      # creates a Creatable using the provided hash and the attr_reader fields, or if given #fields_to_map instead
+      # The parameters will be passed to initialize the object in the same order as they are passed to attr_reader
+      # or #fields_to_map
+      # @param hash [Hash, nil] the given hash to convert to an object
+      # @return the created object, or nil if the given hash is nil
+      def create(hash)
+        return nil if hash.nil?
+
+        if @fields_to_map.nil? || @fields_to_map.empty?
+          fields = @kodi_fields
+          return nil if @kodi_fields.none? { |it| !hash[it.to_s.gsub('_', '')].nil? }
+        else
+          fields = @fields_to_map
+        end
+
+        mapping = @type_mapping.nil? ? lazy_type_mapping : @type_mapping
+        args = fields.map do |it|
+          field = it.to_s.gsub('_', '')
+          Creatable.extract_field_from_hash(field, hash, mapping)
+        end
+
+        new(*args)
+      end
+
+      # takes a hash and a list of strings and an optional mapping and creates a new array with the created objects
+      # of the hash and fields. If no mapping is provided, the value of this field is returned, otherwise the mapping is
+      # used
+      # @param hash [Hash] the given hash
+      # @param fields [Array<String>] the fields to extract
+      # @param mapping [Hash<String, CreateMap>] optional mapping if a field contains a complex type
+      # @return [Array] an array containing the values of hash[field] in the given field order
+      def self.hash_to_arr(hash, fields, mapping = {})
+        return nil if hash.nil?
+
+        fields.map do |it|
+          field = it.to_s.gsub('_', '')
+          extract_field_from_hash(field, hash, mapping)
+        end
+      end
+
+      # map to self.hash_to_arr. The mapping is taken from #type_mapping
+      def hash_to_arr(hash, fields)
+        Creatable.hash_to_arr(hash, fields, @type_mapping.nil? ? {} : @type_mapping)
+      end
+
+      # extracts the given field from the given hash and optionally applies mapping if given
+      # @param field [String] the field name
+      # @param hash [Hash, nil] the hash where to extract the field from
+      # @param mapping [Hash<String, CreateMap>] optional mapping for complex types
+      # @return the extracted object or nil, if the hash is empty, or [] if the expected value was a list and was nil
+      def self.extract_field_from_hash(field, hash, mapping)
+        map = mapping[field]
+        return nil if hash[field].nil? && map.nil?
+
+        return hash[field] if map.nil?
+
+        return map.type.create_list(hash[field]) if map.is_list
+
+        map.type.create(hash[field])
+      end
+
+      def attr_accessor(*args)
+        attr_reader(*args)
+        attr_writer(*args)
+      end
+
+      def attr_reader(*args)
+        @kodi_fields = args.map { |it| it.to_s.gsub('_', '') }
+
+        args.each do |it|
+          inst_variable_name = "@#{it}".to_sym
+          define_method it do
+            instance_variable_get(inst_variable_name)
+          end
+        end
+      end
+
+      def attr_writer(*args)
+        args.each do |it|
+          inst_variable_name = "@#{it}".to_sym
+          define_method "#{it}=" do |new_value|
+            instance_variable_set(inst_variable_name, new_value)
+          end
+        end
+      end
+
+      # mapping class with the type and if it is a list field or not
+      class CreateMap
+
+        attr_reader :type, :is_list
+
+        def initialize(type, is_list = false)
+          @type = type
+          @is_list = is_list
+        end
+      end
+    end
+  end
+end

data/lib/kodi_client/extensions/iterable.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module KodiClient
+  module Extensions
+    # offers iterable methods
+    module Iterable
+
+      # @return [Array<String>] returns all constant values if sorted order
+      def all_properties
+        constants.map { |it| const_get(it) }.sort!
+      end
+    end
+  end
+end

data/lib/kodi_client/kodi_error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module KodiClient
+  # represents an error response
+  class KodiError
+    include Extensions::Comparable
+    attr_reader :code, :message
+
+    def initialize(hash)
+      @code = hash['code']
+      @message = hash['message']
+    end
+  end
+end

data/lib/kodi_client/kodi_method.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module KodiClient
+
+  # the client that stores
+  class KodiMethod
+
+    def apply_options(options)
+      @endpoint_url = "#{options.tls ? 'https://' : 'http://'}#{options.ip}:#{options.port}/jsonrpc"
+      @options = options
+    end
+
+    def invoke_api(request)
+      h = request.instance_variables.each_with_object({}) do |var, hash|
+        hash[var.to_s.delete('@')] = request.instance_variable_get(var)
+      end
+
+      @http_client ||= build_client
+      response = @http_client.post(@endpoint_url, json: h).to_s
+      JSON.parse(response)
+    end
+
+    def build_client
+      client = HTTP.headers(Content_Type: 'application/json')
+      if !@options.username.nil? && !@options.password.nil?
+        client = client.basic_auth({ user: @options.username, pass: @options.password })
+      end
+
+      client
+    end
+
+    private :build_client
+  end
+end

data/lib/kodi_client/{options.rb → kodi_options.rb}

@@ -2,7 +2,7 @@
 
 module KodiClient
   # holds all options like ip, port, credentials
-  class Options
+  class KodiOptions
 
     attr_accessor :ip, :port, :username, :password, :tls
 

data/lib/kodi_client/kodi_request.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module KodiClient
+  # represents a kodi requests
+  class KodiRequest
+
+    attr_accessor :id, :jsonrpc, :method, :params
+
+    def initialize(kodi_id, method, params = {}, jsonrpc = '2.0')
+      @id = kodi_id
+      @jsonrpc = jsonrpc
+      @method = method
+      @params = params
+    end
+  end
+end

data/lib/kodi_client/kodi_response.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module KodiClient
+  # represents a kodi response
+  class KodiResponse
+    include Extensions::Comparable
+
+    attr_reader :id, :jsonrpc, :result, :error
+
+    def initialize(hash)
+      @id = hash['id']
+      @jsonrpc = hash['jsonrpc']
+      @result = hash['result']
+      @error = KodiError.new(hash['error']) unless hash['error'].nil?
+    end
+
+    def error?
+      !@error.nil?
+    end
+  end
+end

data/lib/kodi_client/{method → methods}/addons.rb

@@ -1,13 +1,9 @@
 # frozen_string_literal: true
 
-require 'kodi_client/kodi_module'
-require 'kodi_client/global_types/addon_types'
-require 'kodi_client/global_types/list_types'
-
 module KodiClient
-  module Modules
+  module Methods
     # contains all Kodi Application methods
-    class Addons < KodiModule
+    class Addons < KodiMethod
 
       EXECUTE_ADDON = 'Addons.ExecuteAddon'
       GET_ADDON_DETAILS = 'Addons.GetAddonDetails'
@@ -17,18 +13,18 @@ module KodiClient
       def get_addons(type = Types::Addons::AddonTypes::UNKNOWN,
                      content = Types::Addons::AddonContent::UNKNOWN,
                      enabled = nil, properties = [],
-                     limit = Types::List::ListLimits.new(0, 50), installed = nil, kodi_id = 1)
+                     limits = Types::List::ListLimits.new(0, 50), installed = nil, kodi_id = 1)
         request = KodiRequest.new(kodi_id, GET_ADDONS,
                                   {
                                     'type' => type,
                                     'content' => content,
                                     'enabled' => enabled.nil? || !enabled ? 'all' : 'enabled',
                                     'properties' => properties,
-                                    'limits' => { 'start' => limit.list_start, 'end' => limit.list_end },
+                                    'limits' => limits.to_h,
                                     'installed' => installed.nil? || !installed ? 'all' : 'installed'
                                   })
         json = invoke_api(request)
-        result = Types::Addons::Addons.create(json['result'])
+        result = Types::Addons::GetAddonsReturned.create(json['result'])
         json['result'] = result
         KodiResponse.new(json)
       end
@@ -38,7 +34,7 @@ module KodiClient
                                                                 'properties' => properties })
         json = invoke_api(request)
 
-        result = Types::Addons::Addon.create(json['result'])
+        result = Types::Addons::GetAddonReturned.create(json['result'])
         json['result'] = result
         KodiResponse.new(json)
       end

data/lib/kodi_client/{method → methods}/application.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
 
-require 'kodi_client/kodi_module'
-require 'kodi_client/global_types/application_types'
-
 module KodiClient
-  module Modules
+  module Methods
     # contains all Kodi Application methods
-    class Application < KodiModule
+    class Application < KodiMethod
 
       QUIT = 'Application.Quit'
       SET_MUTE = 'Application.SetMute'