openhab-scripting 2.9.1

data/lib/openhab/core/dsl/entities.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'pp'
+require 'java'
+require 'set'
+require 'core/dsl/group'
+require 'core/dsl/items/number_item'
+require 'core/dsl/items/string_item'
+
+# Automation lookup and injection of OpenHab entities
+java_import org.openhab.core.items.GroupItem
+
+#
+# Implements const_missing to return OpenHAB items or things if mapping to missing name if they exist
+#
+# @param [String] name Capital string that was not set as a constant and to be looked up
+#
+# @return [Object] OpenHAB Item or Thing if their name exist in OpenHAB item and thing regestries
+#
+def Object.const_missing(name)
+  EntityLookup.lookup_item(name) || EntityLookup.lookup_thing(name) || super
+end
+
+#
+# Manages access to OpenHAB entities
+#
+module EntityLookup
+  #
+  # Decorate items with Ruby wrappers
+  #
+  # @param [Array] items Array of items to decorate
+  #
+  # @return [Array] Array of decorated items
+  #
+  def self.decorate_items(*items)
+    items.flatten.map do |item|
+      case item
+      when GroupItem
+        group = item
+        item = OpenHAB::Core::DSL::Groups::Group.new(Set.new(EntityLookup.decorate_items(item.all_members.to_a)))
+        item.group = group
+        item
+      when Java::Org.openhab.core.library.items::NumberItem
+        OpenHAB::Core::DSL::Items::NumberItem.new(item)
+      when Java::Org.openhab.core.library.items::StringItem
+        OpenHAB::Core::DSL::Items::StringItem.new(item)
+      else
+        item
+      end
+    end
+  end
+
+  #
+  # Loops up a Thing in the OpenHAB registry replacing '_' with ':'
+  #
+  # @param [String] name of Thing to lookup in Thing registry
+  #
+  # @return [Thing] if found, nil otherwise
+  #
+  def self.lookup_thing(name)
+    # Convert from : syntax to underscore
+    name = name.to_s if name.is_a? Symbol
+
+    # Thing UIDs have at least 3 segements
+    return if name.count('_') < 3
+
+    name = name.gsub('_', ':')
+    # rubocop: disable Style/GlobalVars
+    $things.get(Java::OrgOpenhabCoreThing::ThingUID.new(name))
+    # rubocop: enable Style/GlobalVars
+  end
+
+  #
+  # Lookup OpenHAB items in item registry
+  #
+  # @param [String] name of item to lookup
+  #
+  # @return [Item] OpenHAB item if registry contains a matching item, nil othewise
+  #
+  def self.lookup_item(name)
+    name = name.to_s if name.is_a? Symbol
+    # rubocop: disable Style/GlobalVars
+    item = $ir.get(name)
+    # rubocop: enable Style/GlobalVars
+    EntityLookup.decorate_items(item).first
+  end
+
+  #
+  # Automatically looks up OpenHAB items and things in appropriate registries
+  #
+  # @param [method] method Name of item to lookup
+  # @param [<Type>] args method arguments
+  # @param [<Type>] block supplied to missing method
+  #
+  # @return [Object] Item or Thing if found in registry
+  #
+  def method_missing(method, *args, &block)
+    return if method.to_s == 'scriptLoaded'
+    return if method.to_s == 'scriptUnloaded'
+
+    EntityLookup.lookup_item(method) || EntityLookup.lookup_thing(method) || super
+  end
+end

data/lib/openhab/core/dsl/gems.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'core/log'
+
+begin
+  require 'bundler/inline'
+
+  include Logging
+  logger.debug('Bundler required')
+rescue LoadError
+  include Logging
+  logger.debug('Bundler not found installing')
+
+  begin
+    require 'rubygems/commands/install_command'
+    cmd = Gem::Commands::InstallCommand.new
+    cmd.handle_options ['--no-document', 'bundler', '-v', '2.1.4']
+    cmd.execute
+    logger.debug('Bundler is installed')
+    require 'bundler/inline'
+  rescue Gem::SystemExitException => e
+    if e.exit_code.zero?
+      logger.debug('Bundler is installed')
+      require 'bundler/inline'
+    else
+      logger.error("Error installing bundler, exit code: #{e}")
+    end
+  end
+end

data/lib/openhab/core/dsl/group.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'delegate'
+require 'forwardable'
+require 'openhab/core/dsl/entities'
+
+module OpenHAB
+  module Core
+    module DSL
+      #
+      # Provides access to OpenHAB Groups
+      #
+      module Groups
+        #
+        # Indicator struct interpreted by rules to trigger based on items contained in a group
+        #
+        GroupItems = Struct.new(:group, keyword_init: true)
+
+        #
+        # Provide access to groups as a set
+        #
+        class Groups < SimpleDelegator
+          #
+          # Get a OpenHAB Group by name
+          # @param [String] name of the group to retrieve
+          #
+          # @return [Set] of OpenHAB Groups
+          #
+          def[](name)
+            group = EntityLookup.lookup_item(name)
+            (group.is_a? Group) ? group : nil
+          end
+        end
+
+        #
+        # Retreive all OpenHAB groups
+        #
+        # @return [Set] of OpenHAB Groups
+        #
+        def groups
+          Groups.new(EntityLookup.decorate_items($ir.items.select { |item| item.is_a? GroupItem }))
+        end
+
+        # Group class that provides access to OpenHAB group object and delegates other methods to
+        # a set of group items
+        class Group < SimpleDelegator
+          extend Forwardable
+
+          java_import org.openhab.core.items.GroupItem
+
+          # @return [org.openhab.core.items.GroupItem] OpenHAB Java Group Item
+          attr_accessor :group
+
+          # @!macro [attach] def_delegators
+          #   @!method $2
+          #     Forwards to org.openhab.core.items.GroupItem
+          #     @see org::openhab::core::items::GroupItem
+          def_delegator :@group, :name
+          def_delegator :@group, :label
+
+          #
+          # Gets members of this group that are themselves a group
+          #
+          # @return [Set] Set of members that are of type group
+          #
+          def groups
+            group.members.grep(org.openhab.core.items.GroupItem)
+          end
+
+          #
+          # Wraps the group in a struct, this method is intended to be called
+          # as an indicator to the rule method that the user wishes to trigger
+          # based on changes to group items
+          #
+          # @return [GroupItems] Indicator struct used by rules engine to trigger based on item changes
+          #
+          def items
+            GroupItems.new(group: group)
+          end
+
+          #
+          # @return [String] List of groups seperated by commas
+          #
+          def to_s
+            "[#{map(&:to_s).join(',')}]"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openhab/core/dsl/items/items.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'java'
+require 'openhab/core/dsl/entities'
+
+module OpenHAB
+  module Core
+    module DSL
+      #
+      # Manages OpenHAB items
+      #
+      module Items
+        #
+        # Delegates to underlying set of all OpenHAB Items, provides convenience methods
+        #
+        class Items < SimpleDelegator
+          # Fetches the named item from the the ItemRegistry
+          # @param [String] name
+          # @return Item from registry, nil if item missing or requested item is a Group Type
+          def[](name)
+            # rubocop: disable Style/GlobalVars
+            item = $ir.getItem(name)
+            # rubocop: enable Style/GlobalVars
+            (item.is_a? GroupItem) ? nil : item
+          end
+        end
+
+        java_import org.openhab.core.items.GroupItem
+        # Fetches all non-group items from the item registry
+        # @return [OpenHAB::Core::DSL::Items::Items]
+        def items
+          # rubocop: disable Style/GlobalVars
+          Items.new(EntityLookup.decorate_items($ir.items.reject { |item| item.is_a? GroupItem }))
+          # rubocop: enable Style/GlobalVars
+        end
+      end
+    end
+  end
+end

data/lib/openhab/core/dsl/items/number_item.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+require 'forwardable'
+require 'java'
+require 'openhab/core/dsl/types/quantity'
+
+module OpenHAB
+  module Core
+    module DSL
+      module Items
+        #
+        # Delegation to OpenHAB Number Item
+        #
+        class NumberItem < Numeric
+          extend Forwardable
+
+          def_delegator :@number_item, :to_s
+
+          java_import org.openhab.core.library.types.DecimalType
+          java_import org.openhab.core.library.types.QuantityType
+          java_import 'tec.uom.se.format.SimpleUnitFormat'
+          java_import 'tec.uom.se.AbstractUnit'
+
+          #
+          # Create a new NumberItem
+          #
+          # @param [Java::Org::openhab::core::library::items::NumberItem] number_item OpenHAB number item to delegate to
+          #
+          def initialize(number_item)
+            @number_item = number_item
+            super()
+          end
+
+          #
+          # Check if NumberItem is truthy? as per defined by library
+          #
+          # @return [Boolean] True if item is not in state UNDEF or NULL and value is not zero.
+          #
+          def truthy?
+            @number_item.state? && @number_item.state != DecimalType::ZERO
+          end
+
+          #
+          # Coerce objects into a NumberItem
+          #
+          # @param [Object] other object to coerce to a NumberItem if possible
+          #
+          # @return [Object] NumberItem, QuantityTypes, BigDecimal or nil depending on NumberItem configuration and/or supplied object
+          #
+          def coerce(other)
+            logger.trace("Coercing #{self} as a request from  #{other.class}")
+            case other
+            when Quantity
+              as_qt = to_qt
+              logger.trace("Converted #{self} to a Quantity #{as_qt}")
+              [other, as_qt]
+            when Numeric
+              if dimension
+                [Quantity.new(other), to_qt]
+              elsif @number_item.state?
+                [BigDecimal(other), @number_item.state.to_big_decimal.to_d]
+              end
+            else
+              logger.trace("#{self} cannot be coereced to #{other.class}")
+              nil
+            end
+          end
+
+          #
+          # Compare NumberItem to supplied object
+          #
+          # @param [Object] other object to compare to
+          #
+          # @return [Integer] -1,0,1 or nil depending on value supplied, nil comparison to supplied object is not possible.
+          #
+          def <=>(other)
+            logger.trace("Comparing #{self} to #{other}")
+            case other
+            when NumberItem
+              if other.dimension
+                logger.trace('Other is dimensioned, converting self and other to QuantityTypes to compare')
+                to_qt <=> other.to_qt
+              else
+                @number_item.state <=> other.state
+              end
+            when Numeric
+              @number_item.state.to_big_decimal.to_d <=> BigDecimal(other)
+            when String
+              @number_item.state <=> QuantityType.new(other) if dimension
+            end
+          end
+
+          #
+          # Convert NumberItem to a Quantity
+          #
+          # @param [Object] other String or Unit representing an OpenHAB Unit
+          #
+          # @return [OpenHAB::Core::DSL::Types::Quantity] NumberItem converted to supplied Unit
+          #
+          def |(other)
+            other = SimpleUnitFormat.instance.unitFor(other) if other.is_a? String
+
+            if dimension
+              to_qt | other
+            else
+              Quantity.new(QuantityType.new(to_d.to_java, other))
+            end
+          end
+
+          #
+          # Convert NumberItem to a Quantity
+          #
+          # @return [OpenHAB::Core::DSL::Types::Quantity] NumberItem converted to a QuantityUnit
+          #
+          def to_qt
+            if dimension
+              Quantity.new(@number_item.get_state_as(QuantityType))
+            else
+              Quantity.new(QuantityType.new(to_d.to_java, AbstractUnit::ONE))
+            end
+          end
+
+          #
+          # Converts the NumberItem to an Integer
+          #
+          # @return [Integer] NumberItem as an integer
+          #
+          def to_i
+            to_d&.to_i
+          end
+
+          #
+          # Converts the NumberItem to a float
+          #
+          # @return [Float] NumberItem as a float
+          #
+          def to_f
+            to_d&.to_f
+          end
+
+          #
+          # Converts the NumberItem to a BigDecimal
+          #
+          # @return [BigDecimal] NumberItem as a BigDecimal
+          #
+          def to_d
+            @number_item.state.to_big_decimal.to_d if @number_item.state.respond_to? :to_big_decimal
+          end
+
+          #
+          # Get the Dimension attached to the NumberItem
+          #
+          # @return [Java::org::openhab::core::library::types::QuantityType] dimension
+          #
+          def dimension
+            @number_item.dimension
+          end
+
+          #
+          # Forward missing methods to Openhab Number Item if they are defined
+          #
+          # @param [String] meth method name
+          # @param [Array] args arguments for method
+          # @param [Proc] block <description>
+          #
+          # @return [Object] Value from delegated method in OpenHAB NumberItem
+          #
+          def method_missing(meth, *args, &block)
+            if @number_item.respond_to?(meth)
+              @number_item.__send__(meth, *args, &block)
+            elsif ::Kernel.method_defined?(meth) || ::Kernel.private_method_defined?(meth)
+              ::Kernel.instance_method(meth).bind_call(self, *args, &block)
+            else
+              super(meth, *args, &block)
+            end
+          end
+
+          %w[+ - * /].each do |operation|
+            define_method(operation) do |other|
+              logger.trace("Execution math operation '#{operation}' on #{inspect} with #{other.inspect}")
+              if other.is_a? NumberItem
+                logger.trace('Math operations is between two NumberItems.')
+                if dimension && other.dimension
+                  # If both numbers have dimensions, do the math on the quantity types.
+                  logger.trace("Both objects have dimensions self='#{dimension}' other='#{other.dimension}'")
+                  to_qt.public_send(operation, other.to_qt)
+                elsif dimension && !other.dimension
+                  # If this number has dimension and the other does not, do math with this quantity type and the other as a big decimal
+                  logger.trace("Self has dimension self='#{dimension}' other lacks dimension='#{other}'")
+                  to_qt.public_send(operation, other)
+                elsif other.dimension
+                  # If this number has no dimension and the other does, convert this into a dimensionless quantity
+                  logger.trace("Self has no dimension self='#{self}' other has dimension='#{other.dimension}'")
+                  to_qt.public_send(operation, other)
+                else
+                  logger.trace("Both objects lack dimension, self='#{self}' other='#{other}'")
+                  # If nothing has a dimension, just use BigDecimals
+                  to_d.public_send(operation, other.to_d)
+                end
+              elsif other.is_a? Numeric
+                to_d.public_send(operation, BigDecimal(other))
+              elsif dimension && other.is_a?(String)
+                to_qt.public_send(operation, Quantity.new(other))
+              elsif other.respond_to? :coerce
+                a, b = other.coerce(to_d)
+                a.public_send(operation, b)
+              else
+                raise TypeError, "#{other.class} can't be coerced into a NumberItem"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end