ruby_home 0.2.5 → 0.2.6

data/lib/ruby_home/configuration.rb

@@ -4,15 +4,15 @@ module RubyHome
   class Configuration
     extend Forwardable
 
-    CATEGORIES_FILEPATH = (File.dirname(__FILE__) + '/config/categories.yml').freeze
+    CATEGORIES_FILEPATH = (File.dirname(__FILE__) + "/config/categories.yml").freeze
     CATEGORIES = YAML.load_file(CATEGORIES_FILEPATH).freeze
 
     def initialize(accessory_info = AccessoryInfo.instance)
       @accessory_info = accessory_info
     end
 
-    DEFAULT_NAME = -'RubyHome'
-    DEFAULT_HOST = -'0.0.0.0'
+    DEFAULT_NAME = -"RubyHome"
+    DEFAULT_HOST = -"0.0.0.0"
     DEFAULT_PORT = 4567
     DEFAULT_MODEL_NAME = DEFAULT_NAME
     DEFAULT_DISCOVERY_NAME = DEFAULT_NAME
@@ -40,7 +40,7 @@ module RubyHome
 
     def category_identifier=(value)
       if value.is_a?(Symbol)
-        raise UnknownCategoriyIdentifierError if !CATEGORIES.include?(value)
+        raise UnknownCategoriyIdentifierError unless CATEGORIES.include?(value)
         @category_identifier = CATEGORIES[value]
       else
         @category_identifier = value.to_i

data/lib/ruby_home/device_id.rb

@@ -1,12 +1,12 @@
 module RubyHome
   module DeviceID
     class << self
-      DELIMITER = ':'
+      DELIMITER = ":"
 
       # Device ID of the accessory must be a unique random number generated at every
       # factory reset and must persist across reboots
 
-      def generate(digits=12)
+      def generate(digits = 12)
         random_hexadecimals(digits)
           .map(&:upcase)
           .each_slice(2)
@@ -18,7 +18,7 @@ module RubyHome
         rand(15).to_s(16)
       end
 
-      def random_hexadecimals(digits=12)
+      def random_hexadecimals(digits = 12)
         digits
           .times
           .map { random_hexadecimal }

data/lib/ruby_home/dns/service.rb

@@ -1,12 +1,12 @@
 module RubyHome
   module DNS
     class Service
-      def initialize(configuration: )
+      def initialize(configuration:)
         @configuration = configuration
       end
 
       def update
-        return if RbConfig::CONFIG['target_os'] =~ /linux/
+        return if /linux/.match?(RbConfig::CONFIG["target_os"])
 
         dnssd_service.add_record(DNSSD::Record::TXT, text_record.encode)
       end
@@ -20,9 +20,7 @@ module RubyHome
       attr_reader :configuration
 
       def dnssd_service
-        @_dnssd_service ||= begin
-          DNSSD::Service.register(name, type, nil, port, host, text_record)
-        end
+        @_dnssd_service ||= DNSSD::Service.register(name, type, nil, port, host, text_record)
       end
 
       def name
@@ -30,7 +28,7 @@ module RubyHome
       end
 
       def type
-        -'_hap._tcp'
+        -"_hap._tcp"
       end
 
       def port

data/lib/ruby_home/dns/text_record.rb

@@ -12,14 +12,14 @@ module RubyHome
 
     def to_hash
       {
-        'c#' => current_configuration_number,
-        'ci' => accessory_category_identifier,
-        'ff' => feature_flags,
-        'id' => device_id,
-        'md' => model_name,
-        'pv' => protocol_version,
-        's#' => current_state_number,
-        'sf' => status_flags
+        "c#" => current_configuration_number,
+        "ci" => accessory_category_identifier,
+        "ff" => feature_flags,
+        "id" => device_id,
+        "md" => model_name,
+        "pv" => protocol_version,
+        "s#" => current_state_number,
+        "sf" => status_flags
       }
     end
 
@@ -52,7 +52,7 @@ module RubyHome
 
     STATUS_FLAGS = {
       PAIRED: 0,
-      NOT_PAIRED: 1,
+      NOT_PAIRED: 1
     }.freeze
 
     def status_flags

data/lib/ruby_home/errors.rb

@@ -1,4 +1,5 @@
 module RubyHome
   class RubyHomeError < StandardError; end
+
   class UnknownValueError < RubyHomeError; end
 end

data/lib/ruby_home/factories/characteristic_factory.rb

@@ -1,6 +1,6 @@
 module RubyHome
   class CharacteristicFactory
-    def self.create(characteristic_name, service: , subtype: 'default' , value: nil)
+    def self.create(characteristic_name, service:, subtype: "default", value: nil)
       new(
         characteristic_name: characteristic_name,
         service: service,
@@ -36,48 +36,48 @@ module RubyHome
 
     private
 
-      def initialize(characteristic_name:, service:, subtype:, value:)
-        @characteristic_name = characteristic_name.to_sym
-        @service = service
-        @subtype = subtype
-        @requested_value = value
-      end
+    def initialize(characteristic_name:, service:, subtype:, value:)
+      @characteristic_name = characteristic_name.to_sym
+      @service = service
+      @subtype = subtype
+      @requested_value = value
+    end
 
-      attr_reader :service, :characteristic_name, :subtype
+    attr_reader :service, :characteristic_name, :subtype
 
-      def accessory
-        service.accessory
-      end
+    def accessory
+      service.accessory
+    end
 
-      def template
-        @template ||= CharacteristicTemplate.find_by(name: characteristic_name)
-      end
+    def template
+      @template ||= CharacteristicTemplate.find_by(name: characteristic_name)
+    end
 
-      def value_object
-        value_object_class.new(template, @requested_value)
-      end
+    def value_object
+      value_object_class.new(template, @requested_value)
+    end
 
-      def value_object_class
-        BaseValue.value_for_template(template)
-      end
+    def value_object_class
+      BaseValue.value_for_template(template)
+    end
 
-      def persisted_characteristic
-        IdentifierCache.find_by(
-          accessory_id: service.accessory_id,
-          service_uuid: service.uuid,
-          uuid: template.uuid,
-          subtype: subtype
-        )
-      end
+    def persisted_characteristic
+      IdentifierCache.find_by(
+        accessory_id: service.accessory_id,
+        service_uuid: service.uuid,
+        uuid: template.uuid,
+        subtype: subtype
+      )
+    end
 
-      def persist_characteristic(characteristic)
-        IdentifierCache.create(
-          accessory_id: characteristic.accessory_id,
-          instance_id: characteristic.instance_id,
-          service_uuid: service.uuid,
-          uuid: characteristic.uuid,
-          subtype: subtype
-        )
-      end
+    def persist_characteristic(characteristic)
+      IdentifierCache.create(
+        accessory_id: characteristic.accessory_id,
+        instance_id: characteristic.instance_id,
+        service_uuid: service.uuid,
+        uuid: characteristic.uuid,
+        subtype: subtype
+      )
+    end
   end
 end

data/lib/ruby_home/factories/service_factory.rb

@@ -1,6 +1,6 @@
 module RubyHome
   class ServiceFactory
-    def self.create(service_name, accessory: Accessory.new, subtype: 'default', **options)
+    def self.create(service_name, accessory: Accessory.new, subtype: "default", **options)
       new(
         service_name: service_name,
         accessory: accessory,
@@ -14,7 +14,7 @@ module RubyHome
         accessory: accessory,
         description: template.description,
         name: service_name,
-        uuid: template.uuid,
+        uuid: template.uuid
       )
 
       if persisted_service
@@ -38,87 +38,87 @@ module RubyHome
 
     private
 
-      ACCESSORY_INFORMATION_OPTIONS = [
-        :firmware_revision,
-        :manufacturer,
-        :model,
-        :name,
-        :serial_number
-      ].freeze
-
-      def initialize(service_name:, accessory:, subtype:, **options)
-        @service_name = service_name.to_sym
-        @accessory = accessory
-        @subtype = subtype
-        @options = options
-      end
+    ACCESSORY_INFORMATION_OPTIONS = [
+      :firmware_revision,
+      :manufacturer,
+      :model,
+      :name,
+      :serial_number
+    ].freeze
+
+    def initialize(service_name:, accessory:, subtype:, **options)
+      @service_name = service_name.to_sym
+      @accessory = accessory
+      @subtype = subtype
+      @options = options
+    end
 
-      attr_reader :service_name, :accessory, :subtype, :options
-
-      def create_required_characteristics(service)
-        template.required_characteristics.each do |characteristic_template|
-          characteristic_name = characteristic_template.name
-          CharacteristicFactory.create(
-            characteristic_template.name,
-            service: service,
-            subtype: subtype,
-            value: options[characteristic_name]
-          )
-        end
-      end
+    attr_reader :service_name, :accessory, :subtype, :options
 
-      def create_optional_characteristics(service)
-        optional_characteristic_templates.each do |characteristic_template|
-          characteristic_name = characteristic_template.name
-          CharacteristicFactory.create(
-            characteristic_name,
-            service: service,
-            subtype: subtype,
-            value: options[characteristic_name]
-          )
-        end
+    def create_required_characteristics(service)
+      template.required_characteristics.each do |characteristic_template|
+        characteristic_name = characteristic_template.name
+        CharacteristicFactory.create(
+          characteristic_template.name,
+          service: service,
+          subtype: subtype,
+          value: options[characteristic_name]
+        )
       end
+    end
 
-      def optional_characteristic_templates
-        template.optional_characteristics.select do |characteristic_template|
-          options.keys.include?(characteristic_template.name)
-        end
+    def create_optional_characteristics(service)
+      optional_characteristic_templates.each do |characteristic_template|
+        characteristic_name = characteristic_template.name
+        CharacteristicFactory.create(
+          characteristic_name,
+          service: service,
+          subtype: subtype,
+          value: options[characteristic_name]
+        )
       end
+    end
 
-      def accessory_information_factory?
-        service_name == :accessory_information
+    def optional_characteristic_templates
+      template.optional_characteristics.select do |characteristic_template|
+        options.key?(characteristic_template.name)
       end
+    end
 
-      def create_accessory_information
-        return if accessory.has_accessory_information?
+    def accessory_information_factory?
+      service_name == :accessory_information
+    end
 
-        ServiceFactory.create(
-          :accessory_information,
-          accessory: accessory,
-          subtype: 'accessory_information',
-          **options.slice(*ACCESSORY_INFORMATION_OPTIONS)
-        )
-      end
+    def create_accessory_information
+      return if accessory.has_accessory_information?
 
-      def template
-        @template ||= ServiceTemplate.find_by(name: service_name)
-      end
+      ServiceFactory.create(
+        :accessory_information,
+        accessory: accessory,
+        subtype: "accessory_information",
+        **options.slice(*ACCESSORY_INFORMATION_OPTIONS)
+      )
+    end
 
-      def persisted_service
-        IdentifierCache.find_by(
-          accessory_id: accessory.id,
-          uuid: template.uuid,
-          subtype: subtype
-        )
-      end
+    def template
+      @template ||= ServiceTemplate.find_by(name: service_name)
+    end
 
-      def persist_service(service)
-        IdentifierCache.create(
-          accessory_id: accessory.id,
-          instance_id: service.instance_id,
-          uuid: template.uuid,
-          subtype: subtype
-        )
-      end
+    def persisted_service
+      IdentifierCache.find_by(
+        accessory_id: accessory.id,
+        uuid: template.uuid,
+        subtype: subtype
+      )
+    end
+
+    def persist_service(service)
+      IdentifierCache.create(
+        accessory_id: accessory.id,
+        instance_id: service.instance_id,
+        uuid: template.uuid,
+        subtype: subtype
+      )
+    end
   end
 end

data/lib/ruby_home/factories/templates/characteristic_template.rb

@@ -1,7 +1,8 @@
 module RubyHome
   class CharacteristicTemplate
-    FILEPATH = (File.dirname(__FILE__) + '/../../config/characteristics.yml').freeze
-    DATA = YAML.load_file(FILEPATH).freeze
+    FILENAMES = %w[characteristics.yml manual_characteristics.yml].freeze
+    FILEPATHS = FILENAMES.map { |filename| File.join(__dir__, "..", "..", "config", filename) }.freeze
+    DATA = FILEPATHS.flat_map { |filepath| YAML.load_file(filepath) }.freeze
 
     def self.all
       @@all ||= DATA.map { |data| new(**data) }
@@ -15,18 +16,17 @@ module RubyHome
       end
     end
 
-    def initialize(name:, description:, uuid:, format:, unit:, permissions:, properties:, constraints: )
+    def initialize(name:, description:, uuid:, format:, unit:, properties:, constraints:)
       @name = name
       @description = description
       @uuid = uuid
       @format = format
       @unit = unit
-      @permissions = permissions
       @properties = properties
       @constraints = constraints
     end
 
-    attr_reader :name, :description, :uuid, :format, :unit, :permissions, :properties
+    attr_reader :name, :description, :uuid, :format, :unit, :properties
 
     def constraints
       @constraints || {}

data/lib/ruby_home/factories/templates/service_template.rb

@@ -1,7 +1,8 @@
 module RubyHome
   class ServiceTemplate
-    FILEPATH = (File.dirname(__FILE__) + '/../../config/services.yml').freeze
-    DATA = YAML.load_file(FILEPATH).freeze
+    FILENAMES = %w[services.yml manual_services.yml].freeze
+    FILEPATHS = FILENAMES.map { |filename| File.join(__dir__, "..", "..", "config", filename) }.freeze
+    DATA = FILEPATHS.flat_map { |filepath| YAML.load_file(filepath) }.freeze
 
     def self.all
       @all ||= DATA.map { |data| new(**data) }
@@ -15,25 +16,25 @@ module RubyHome
       end
     end
 
-    def initialize(name:, description:, uuid:, optional_characteristics_uuids:, required_characteristics_uuids:)
+    def initialize(name:, description:, uuid:, optional_characteristic_names:, required_characteristic_names:)
       @name = name
       @description = description
       @uuid = uuid
-      @optional_characteristics_uuids = optional_characteristics_uuids
-      @required_characteristics_uuids = required_characteristics_uuids
+      @optional_characteristic_names = optional_characteristic_names
+      @required_characteristic_names = required_characteristic_names
     end
 
-    attr_reader :name, :description, :uuid, :optional_characteristics_uuids, :required_characteristics_uuids
+    attr_reader :name, :description, :uuid, :optional_characteristic_names, :required_characteristic_names
 
     def optional_characteristics
-      @optional_characteristics ||= optional_characteristics_uuids.map do |uuid|
-        CharacteristicTemplate.find_by(uuid: uuid)
+      @optional_characteristics ||= optional_characteristic_names.map do |name|
+        CharacteristicTemplate.find_by(name: name)
       end
     end
 
     def required_characteristics
-      @required_characteristics ||= required_characteristics_uuids.map do |uuid|
-        CharacteristicTemplate.find_by(uuid: uuid)
+      @required_characteristics ||= required_characteristic_names.map do |name|
+        CharacteristicTemplate.find_by(name: name)
       end
     end
   end