mqtt-homie 0.1.1 → 0.1.2

data/lib/mqtt/homie/device.rb

@@ -1,108 +1,108 @@
-require "sys/uname"
-require "socket"
-
-module MQTT
-  module Homie
-    class Device < HomieObject
-      class << self
-        include Network
-      end
-
-      HOMIE_VERSION = "3.0.1"
-      DEFAULT_STAT_REFRESH = 60  # seconds
-      DEFAULT_IMPLEMENTATION = "mqtt-homie-#{VERSION}"
-
-      class Firmware < HomieObject
-        class << self
-          def default_fw_name
-            uname.sysname rescue uname.caption rescue "Unknown"
-          end
-
-          def default_fw_version
-            uname.release rescue uname.build_number rescue "Unknown"
-          end
-
-          def uname
-            @uname ||= Sys::Uname.uname
-          end
-        end
-
-        homie_attr :name, default: default_fw_name, required: true
-        homie_attr :version, default: default_fw_version, required: true
-      end
-
-      # statistics should be sent every interval seconds
-      # homie/device_id/$stats
-      class Statistics < HomieObject
-        homie_attr :interval, required: true, default: 60
-        homie_attr :boot_time, default: lambda { |i| Time.now }, hidden: true
-        homie_attr :signal, datatype: Integer
-        homie_attr :cputemp, datatype: Integer
-        homie_attr :cpuload, datatype: Float
-        homie_attr :battery, datatype: Integer
-        homie_attr :freeheap, datatype: Integer
-        homie_attr :supply, datatype: Float
-
-        def homie_attributes
-          super.merge("uptime" => (Time.now - @boot_time).to_i)
-        end
-      end
-
-      attr_reader :fw, :stats
-      attr_accessor :use_stats, :use_fw
-
-      homie_id
-      homie_attr :name, required: true
-      homie_attr :state, default: :init, required: true
-      homie_attr :nodes, datatype: Array, default: [], immutable: true
-      homie_attr :localip, default: default_localip, required: true
-      homie_attr :mac, default: default_mac, required: true
-      homie_attr :implementation, default: DEFAULT_IMPLEMENTATION
-
-      def initialize(options = {})
-        super(options)
-        @stats = Statistics.new(options)
-        @fw = Firmware.new(subhash(options, "fw_"))
-
-        @use_stats = options.include?(:use_stats) ? options[:use_stats] : true
-        @use_fw = options.include?(:use_fw) ? options[:use_fw] : true
-      end
-
-      def node(id)
-        @nodes.find { |i| i.id == id }
-      end
-
-      # device attributes must be sent when connection to broker is established or re-established
-      # homie/device_id/
-      def homie_attributes
-        data = super.merge({
-          "$homie" => HOMIE_VERSION,
-        })
-
-        data.merge!({
-          "$fw/name" => @fw.name,
-          "$fw/version" => @fw.version,
-        }) if @use_fw
-
-        @nodes.each do |node|
-          node.homie_attributes.each do |k, v|
-            data[node.topic + "/" + k] = v
-          end
-        end
-        data
-      end
-
-      private
-
-      def subhash(data, prefix)
-        result = {}
-        data.each do |key, value|
-          next unless key.to_s.start_with?(prefix)
-          key = key.to_s.sub(/^#{prefix}/, "")
-          result[key.to_sym] = value
-        end
-        result
-      end
-    end
-  end
-end
+require "sys/uname"
+require "socket"
+
+module MQTT
+  module Homie
+    class Device < HomieObject
+      class << self
+        include Network
+      end
+
+      HOMIE_VERSION = "3.0.1"
+      DEFAULT_STAT_REFRESH = 60  # seconds
+      DEFAULT_IMPLEMENTATION = "mqtt-homie-#{VERSION}"
+
+      class Firmware < HomieObject
+        class << self
+          def default_fw_name
+            uname.sysname rescue uname.caption rescue "Unknown"
+          end
+
+          def default_fw_version
+            uname.release rescue uname.build_number rescue "Unknown"
+          end
+
+          def uname
+            @uname ||= Sys::Uname.uname
+          end
+        end
+
+        homie_attr :name, default: default_fw_name, required: true
+        homie_attr :version, default: default_fw_version, required: true
+      end
+
+      # statistics should be sent every interval seconds
+      # homie/device_id/$stats
+      class Statistics < HomieObject
+        homie_attr :interval, required: true, default: 60
+        homie_attr :boot_time, default: lambda { |i| Time.now }, hidden: true
+        homie_attr :signal, datatype: Integer
+        homie_attr :cputemp, datatype: Integer
+        homie_attr :cpuload, datatype: Float
+        homie_attr :battery, datatype: Integer
+        homie_attr :freeheap, datatype: Integer
+        homie_attr :supply, datatype: Float
+
+        def homie_attributes
+          super.merge("uptime" => (Time.now - @boot_time).to_i)
+        end
+      end
+
+      attr_reader :fw, :stats
+      attr_accessor :use_stats, :use_fw
+
+      homie_id
+      homie_attr :name, required: true
+      homie_attr :state, default: :init, required: true
+      homie_attr :nodes, datatype: Array, default: [], immutable: true
+      homie_attr :localip, default: default_localip, required: true
+      homie_attr :mac, default: default_mac, required: true
+      homie_attr :implementation, default: DEFAULT_IMPLEMENTATION
+
+      def initialize(options = {})
+        super(options)
+        @stats = Statistics.new(options)
+        @fw = Firmware.new(subhash(options, "fw_"))
+
+        @use_stats = options.include?(:use_stats) ? options[:use_stats] : true
+        @use_fw = options.include?(:use_fw) ? options[:use_fw] : true
+      end
+
+      def node(id)
+        @nodes.find { |i| i.id == id }
+      end
+
+      # device attributes must be sent when connection to broker is established or re-established
+      # homie/device_id/
+      def homie_attributes
+        data = super.merge({
+          "$homie" => HOMIE_VERSION,
+        })
+
+        data.merge!({
+          "$fw/name" => @fw.name,
+          "$fw/version" => @fw.version,
+        }) if @use_fw
+
+        @nodes.each do |node|
+          node.homie_attributes.each do |k, v|
+            data[node.topic + "/" + k] = v
+          end
+        end
+        data
+      end
+
+      private
+
+      def subhash(data, prefix)
+        result = {}
+        data.each do |key, value|
+          next unless key.to_s.start_with?(prefix)
+          key = key.to_s.sub(/^#{prefix}/, "")
+          result[key.to_sym] = value
+        end
+        result
+      end
+    end
+  end
+end

data/lib/mqtt/homie/device_builder.rb

@@ -1,38 +1,38 @@
-module MQTT
-  module Homie
-    class DeviceBuilder
-      def initialize(options = {})
-        @nodes = []
-        @device_options = options
-      end
-
-      # create device and return it
-      def build
-        build_node if @node_data
-        MQTT::Homie::Device.new(@device_options.merge(nodes: @nodes))
-      end
-
-      def node(options = {})
-        raise "node key/value list expected" unless options.kind_of?(Hash)
-        build_node if @node_data
-        @node_data = options
-        @properties = []
-        self
-      end
-
-      def property(options = {})
-        raise "property key/value list expected" unless options.kind_of?(Hash)
-        @properties << MQTT::Homie::Property.new(options)
-        self
-      end
-
-      private
-
-      def build_node
-        @nodes << MQTT::Homie::Node.new(@node_data.merge(properties: @properties))
-        @node_data = nil
-        @propertes = nil
-      end
-    end
-  end
-end
+module MQTT
+  module Homie
+    class DeviceBuilder
+      def initialize(options = {})
+        @nodes = []
+        @device_options = options
+      end
+
+      # create device and return it
+      def build
+        build_node if @node_data
+        MQTT::Homie::Device.new(@device_options.merge(nodes: @nodes))
+      end
+
+      def node(options = {})
+        raise "node key/value list expected" unless options.kind_of?(Hash)
+        build_node if @node_data
+        @node_data = options
+        @properties = []
+        self
+      end
+
+      def property(options = {})
+        raise "property key/value list expected" unless options.kind_of?(Hash)
+        @properties << MQTT::Homie::Property.new(options)
+        self
+      end
+
+      private
+
+      def build_node
+        @nodes << MQTT::Homie::Node.new(@node_data.merge(properties: @properties))
+        @node_data = nil
+        @propertes = nil
+      end
+    end
+  end
+end

data/lib/mqtt/homie/homie_attribute.rb

@@ -1,125 +1,125 @@
-module MQTT
-  module Homie
-    module HomieAttribute
-      def self.included(base)
-        base.send :include, InstanceMethods
-        base.extend ClassMethods
-      end
-
-      module ClassMethods
-        def homie_attr(name, options = {})
-          # define accessors
-          attr_reader name
-
-          unless options[:immutable]
-            define_method("#{name}=") { |value| homie_attr_set(name, value) }
-          end
-
-          # record attribute data
-          @homie_attribute_list ||= []
-          @homie_attribute_list << [name.to_sym, options]
-        end
-
-        def homie_id
-          homie_attr :id, required: true, validate: lambda { |i| valid_id?(i) }, immutable: true, hidden: true
-        end
-
-        def homie_has_id?
-          !!homie_attr_list.detect { |i| i[0] == :id }
-        end
-
-        def homie_attr_list
-          @homie_attribute_list || []
-        end
-
-        def homie_attr_options(name)
-          data = homie_attr_list.find { |i| i[0] == name } || []
-          data[1] || {}
-        end
-      end
-
-      module InstanceMethods
-
-        # initialize all homie attributes from the given hash
-        def homie_attr_init(data = {})
-          self.class.homie_attr_list.each do |name, options|
-            #puts "name: #{name}, default: #{options[:default]}, options: #{options.inspect}"
-            value = data.include?(name) ? data[name] : options[:default]
-            value = value.call(self) if value.kind_of?(Proc)
-            homie_attr_set(name, value)
-          end
-        end
-
-        # set attribute without validation
-        def homie_attr_set!(name, value)
-          instance_variable_set("@#{name}", value)
-        end
-
-        # set attribute with validation
-        def homie_attr_set(name, value)
-          homie_attr_validate(name, value)
-          homie_attr_set!(name, value)
-        end
-
-        def homie_attributes
-          data = {}
-          # if this object has an id, it needs a $ attribute prefix.
-          # otherwise assume it is a hierarchical attribute like $stats/* or $fw/*
-          attrib_prefix = self.class.homie_has_id? ? "$" : ""
-          self.class.homie_attr_list.each do |name, options|
-            next if options[:hidden]
-            key = options[:topic] || (attrib_prefix + name.to_s)
-            value = instance_variable_get("@#{name}")
-            next if value == nil
-            data[key] = value.kind_of?(Array) ? value.collect { |i| i.id }.join(",") : value
-          end
-          data
-        end
-
-        # attribute validation
-        def homie_attr_validate(name, value)
-          options = self.class.homie_attr_options(name)
-
-          if value.nil?
-            required = options[:required]
-            required = required.call(self) if required.kind_of?(Proc)
-            raise "#{name} is required for #{object_type} #{@id}" if required
-          end
-
-          datatype = options[:datatype]
-          if datatype && !value.nil? && !datatype_match?(datatype, value)
-            raise "expected #{name} to be a #{datatype} for #{object_type} #{@id}"
-          end
-
-          enum = options[:enum]
-          if enum.kind_of?(Array) && !value.nil? && !enum.include?(value.to_sym)
-            raise "expected #{name} (#{value}) to be one of #{enum.join(",")}"
-          end
-        end
-
-        private
-
-        def object_type
-          self.class.name.split("::").last
-        end
-
-        def valid_id?(id)
-          id && id.kind_of?(String) && id.match(/^[-a-z0-9]+$/) && !id.start_with?("-")
-        end
-
-        def datatype_match?(datatype, value)
-          return value.kind_of?(datatype) if datatype.kind_of?(Class)
-          case datatype
-          when :boolean
-            return value == true || value == false
-          else
-            raise "unhandled datatype '#{datatype}'"
-          end
-          false
-        end
-
-        #@settable = !!set(options, :settable, default: false)
-      end
-    end
-  end
-end
+module MQTT
+  module Homie
+    module HomieAttribute
+      def self.included(base)
+        base.send :include, InstanceMethods
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def homie_attr(name, options = {})
+          # define accessors
+          attr_reader name
+
+          unless options[:immutable]
+            define_method("#{name}=") { |value| homie_attr_set(name, value) }
+          end
+
+          # record attribute data
+          @homie_attribute_list ||= []
+          @homie_attribute_list << [name.to_sym, options]
+        end
+
+        def homie_id
+          homie_attr :id, required: true, validate: lambda { |i| valid_id?(i) }, immutable: true, hidden: true
+        end
+
+        def homie_has_id?
+          !!homie_attr_list.detect { |i| i[0] == :id }
+        end
+
+        def homie_attr_list
+          @homie_attribute_list || []
+        end
+
+        def homie_attr_options(name)
+          data = homie_attr_list.find { |i| i[0] == name } || []
+          data[1] || {}
+        end
+      end
+
+      module InstanceMethods
+
+        # initialize all homie attributes from the given hash
+        def homie_attr_init(data = {})
+          self.class.homie_attr_list.each do |name, options|
+            #puts "name: #{name}, default: #{options[:default]}, options: #{options.inspect}"
+            value = data.include?(name) ? data[name] : options[:default]
+            value = value.call(self) if value.kind_of?(Proc)
+            homie_attr_set(name, value)
+          end
+        end
+
+        # set attribute without validation
+        def homie_attr_set!(name, value)
+          instance_variable_set("@#{name}", value)
+        end
+
+        # set attribute with validation
+        def homie_attr_set(name, value)
+          homie_attr_validate(name, value)
+          homie_attr_set!(name, value)
+        end
+
+        def homie_attributes
+          data = {}
+          # if this object has an id, it needs a $ attribute prefix.
+          # otherwise assume it is a hierarchical attribute like $stats/* or $fw/*
+          attrib_prefix = self.class.homie_has_id? ? "$" : ""
+          self.class.homie_attr_list.each do |name, options|
+            next if options[:hidden]
+            key = options[:topic] || (attrib_prefix + name.to_s)
+            value = instance_variable_get("@#{name}")
+            next if value == nil
+            data[key] = value.kind_of?(Array) ? value.collect { |i| i.id }.join(",") : value
+          end
+          data
+        end
+
+        # attribute validation
+        def homie_attr_validate(name, value)
+          options = self.class.homie_attr_options(name)
+
+          if value.nil?
+            required = options[:required]
+            required = required.call(self) if required.kind_of?(Proc)
+            raise "#{name} is required for #{object_type} #{@id}" if required
+          end
+
+          datatype = options[:datatype]
+          if datatype && !value.nil? && !datatype_match?(datatype, value)
+            raise "expected #{name} to be a #{datatype} for #{object_type} #{@id}"
+          end
+
+          enum = options[:enum]
+          if enum.kind_of?(Array) && !value.nil? && !enum.include?(value.to_sym)
+            raise "expected #{name} (#{value}) to be one of #{enum.join(",")}"
+          end
+        end
+
+        private
+
+        def object_type
+          self.class.name.split("::").last
+        end
+
+        def valid_id?(id)
+          id && id.kind_of?(String) && id.match(/^[-a-z0-9]+$/) && !id.start_with?("-")
+        end
+
+        def datatype_match?(datatype, value)
+          return value.kind_of?(datatype) if datatype.kind_of?(Class)
+          case datatype
+          when :boolean
+            return value == true || value == false
+          else
+            raise "unhandled datatype '#{datatype}'"
+          end
+          false
+        end
+
+        #@settable = !!set(options, :settable, default: false)
+      end
+    end
+  end
+end

data/lib/mqtt/homie/homie_object.rb

@@ -1,17 +1,17 @@
-require "observer"
-
-module MQTT
-  module Homie
-    class HomieObject
-      include HomieAttribute
-
-      def initialize(options = {})
-        homie_attr_init(options)
-      end
-
-      def topic
-        @id
-      end
-    end
-  end
-end
+require "observer"
+
+module MQTT
+  module Homie
+    class HomieObject
+      include HomieAttribute
+
+      def initialize(options = {})
+        homie_attr_init(options)
+      end
+
+      def topic
+        @id
+      end
+    end
+  end
+end

data/lib/mqtt/homie/network.rb

@@ -1,42 +1,43 @@
-require "macaddr"
-
-module MQTT
-  module Homie
-    module Network
-      def default_localip
-        addr = default_interface[:addresses][0] if default_interface
-        addr ? addr.ip_address : nil
-      end
-
-      def default_mac
-        (default_interface ? default_interface[:hwaddr] : nil) || Mac.addr
-      end
-
-      def default_interface
-        @default_interface ||= interfaces.values.find { |i| i[:default] }
-      end
-
-      def interfaces
-        @interfaces ||= begin
-          interfaces = {}
-          found = false
-          Socket.getifaddrs.each do |ifaddr|
-            ifname = ifaddr.name
-            data = interfaces[ifname] ||= { addresses: [] }
-            next unless addr = ifaddr.addr
-            data[:addresses].push addr if (addr.ipv4? || addr.ipv6?) && usable_address?(addr)
-            data[:hwaddr] = $1 if addr.inspect.match(/hwaddr=([0-9a-fA-F:]+)/)  # doesn't work on windows
-            data[:default] = true unless found
-            data[:name] = ifname
-            found = true
-          end
-          interfaces
-        end
-      end
-
-      def usable_address?(addr)
-        !(addr.ipv4_loopback? || addr.ipv6_loopback? || addr.ipv4_multicast? || addr.ipv6_linklocal?)
-      end
-    end
-  end
-end
+require "macaddr"
+
+module MQTT
+  module Homie
+    module Network
+      def default_localip
+        addr = default_interface[:addresses][0] if default_interface
+        addr ? addr.ip_address : nil
+      end
+
+      def default_mac
+        (default_interface ? default_interface[:hwaddr] : nil) || Mac.addr
+      end
+
+      def default_interface
+        @default_interface ||= interfaces.values.first
+      end
+
+      def interfaces
+        @interfaces ||= begin
+          interfaces = {}
+          Socket.getifaddrs.each do |ifaddr|
+            ifname = ifaddr.name
+            next if ifname == "lo"
+            next unless addr = ifaddr.addr
+
+            data = interfaces[ifname] ||= { addresses: [] }
+            data[:name] = ifname
+            data[:hwaddr] = $1 if addr.inspect.match(/hwaddr=([0-9a-fA-F:]+)/)  # doesn't work on windows
+            if (addr.ipv4? || addr.ipv6?) && usable_address?(addr)
+              data[:addresses].push addr
+            end
+          end
+          interfaces
+        end
+      end
+
+      def usable_address?(addr)
+        !(addr.ipv4_loopback? || addr.ipv6_loopback? || addr.ipv4_multicast? || addr.ipv6_linklocal?)
+      end
+    end
+  end
+end