openhab-scripting 4.46.2 → 5.0.0

data/lib/openhab/core/openhab_setup.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'openhab/log/logger'
-require 'openhab/core/services'
-
-module OpenHAB
-  #
-  # Core support for OpenHAB JRuby Library
-  #
-  module Core
-    include OpenHAB::Log
-
-    # @return [Integer] Number of seconds to wait between checks for automation manager
-    CHECK_DELAY = 10
-    private_constant :CHECK_DELAY
-
-    #
-    # Wait until OpenHAB engine ready to process
-    #
-    def self.wait_till_openhab_ready
-      logger.trace('Checking readiness of OpenHAB')
-      until OpenHAB::Core.automation_manager
-        logger.trace("Automation manager not loaded, checking again in #{CHECK_DELAY} seconds.")
-        sleep CHECK_DELAY
-      end
-      logger.trace 'Automation manager instantiated, OpenHAB ready for rule processing.'
-    end
-  end
-end

data/lib/openhab/core/osgi.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require 'java'
-require 'openhab/log/logger'
-
-module OpenHAB
-  module Core
-    #
-    # OSGI services interface
-    #
-    class OSGI
-      include OpenHAB::Log
-
-      java_import org.osgi.framework.FrameworkUtil
-
-      #
-      # @param name [String] The service name
-      #
-      # @return [Service]
-      #
-      def self.service(name)
-        ref = bundle_context.getServiceReference(name)
-        service = bundle_context.getService(ref) if ref
-        logger.trace "OSGI service(#{service}) found for '#{name}' using OSGI Service Reference #{ref}"
-
-        service
-      end
-
-      #
-      # @param name [String] The service name
-      # @param filter [String] Filter for service names. See https://docs.osgi.org/javadoc/r4v43/core/org/osgi/framework/Filter.html
-      #
-      # @return [Array] An array of services
-      #
-      def self.services(name, filter: nil)
-        bundle_context.getServiceReferences(name, filter)&.map do |reference|
-          bundle_context.getService(reference)
-        end
-      end
-
-      #
-      # Get the bundle context
-      #
-      # @return [java::org::osgi::framework::BundleContext] OSGI bundle context
-      #
-      def self.bundle_context
-        @bundle_context ||= bundle.getBundleContext
-      end
-      private_class_method :bundle_context
-
-      # Get the OSGI Bundle for ScriptExtension Class
-      def self.bundle
-        @bundle ||= FrameworkUtil.getBundle($scriptExtension.class)
-      end
-      private_class_method :bundle
-    end
-  end
-end

data/lib/openhab/core/services.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module OpenHAB
-  #
-  # Core support for OpenHAB JRuby Library
-  #
-  module Core
-    #
-    # Access OpenHAB services
-    #
-
-    # Get the OpenHAB automation manager
-    # @return [AutomationManager] OpenHAB Automation manager
-    def self.automation_manager
-      $scriptExtension.get('automationManager')
-    end
-
-    # Get the OpenHAB rule registry
-    # @return [Registory] OpenHAB rule registry
-    def self.rule_registry
-      $scriptExtension.get('ruleRegistry')
-    end
-  end
-end

data/lib/openhab/dsl/actions.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-require 'java'
-require 'openhab/core/osgi'
-
-module OpenHAB
-  module DSL
-    #
-    # Module to import and streamline access to OpenHAB actions
-    #
-    module Actions
-      include OpenHAB::Log
-
-      OpenHAB::Core::OSGI.services('org.openhab.core.model.script.engine.action.ActionService')&.each do |service|
-        java_import service.actionClass.to_s
-        logger.trace("Loaded ACTION: #{service.actionClass}")
-      end
-      # Import common actions
-      %w[Exec HTTP Ping].each { |action| java_import "org.openhab.core.model.script.actions.#{action}" }
-
-      module_function
-
-      #
-      # Return an OpenHAB Action object for the given scope and thing
-      #
-      # @param scope [String] The action scope
-      # @param thing_uid [String] Thing UID
-      #
-      # @return [Object] OpenHAB action
-      #
-      def actions(scope, thing_uid)
-        $actions.get(scope, thing_uid)
-      end
-
-      #
-      # Gets the list of action objects associated with a specific ThingUID
-      #
-      # @param [org.openhab.core.thing.ThingUID] thing_uid to get associated actions for
-      #
-      # @return [Array] of action objects associated with thing_uid, may be empty
-      #
-      def actions_for_thing(thing_uid)
-        thing_uid = thing_uid.to_s
-        action_keys = $actions.action_keys
-        logger.trace("Registered actions: '#{action_keys}' for thing '#{thing_uid}'")
-        action_keys.map { |action_key| action_key.split('-', 2) }
-                   .select { |action_pair| action_pair.last == thing_uid }
-                   .map(&:first)
-                   .map { |scope| actions(scope, thing_uid) }
-      end
-
-      #
-      # Send notification to an email or broadcast
-      #
-      # @param msg [String] The notification message to send
-      # @param email [String] The email address to send to. If nil, the message will be broadcasted
-      #
-      # @return [void]
-      #
-      def notify(msg, email: nil)
-        unless defined? NotificationAction
-          raise NoMethodError, 'NotificationAction is not available. Please install the OpenHAB cloud addon'
-        end
-
-        if email
-          NotificationAction.sendNotification email.to_s, msg.to_s
-        else
-          NotificationAction.sendBroadcastNotification msg.to_s
-        end
-      end
-
-      #
-      # Say text via OpenHAB Text-To-Speech service, Voice.say()
-      #
-      # @param text [String] The text to say
-      # @param voice [String] Specify a particular voice to use
-      # @param sink [String] Specify a particular sink to output the speech
-      # @param volume [PercentType] Specify the volume for the speech
-      #
-      # @return [void]
-      #
-      def say(text, voice: nil, sink: nil, volume: nil)
-        volume = Types::PercentType.new(volume) unless volume.is_a?(Types::PercentType) || volume.nil?
-        Voice.say text.to_s, voice&.to_s, sink&.to_s, volume
-      end
-
-      #
-      # Play an audio file via OpenHAB sound service, Audio.playSound()
-      #
-      # @param filename [String] The sound file to play
-      # @param sink [String] Specify a particular sink to output the speech
-      # @param volume [PercentType] Specify the volume for the speech
-      #
-      # @return [void]
-      #
-      def play_sound(filename, sink: nil, volume: nil)
-        volume = Types::PercentType.new(volume) unless volume.is_a?(Types::PercentType) || volume.nil?
-        Audio.playSound sink&.to_s, filename.to_s, volume
-      end
-
-      #
-      # Play an audio stream from an URL to the given sink(s). Set url to nil if streaming should be stopped
-      #
-      # @param [String] url The URL of the audio stream
-      # @param [String] sink The audio sink, or nil to use the default audio sink
-      #
-      # @return [void]
-      #
-      def play_stream(url, sink: nil)
-        Audio.playStream sink&.to_s, url
-      end
-    end
-  end
-end

data/lib/openhab/dsl/between.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'time/time_of_day'
-require_relative 'time/month_day'
-
-module OpenHAB
-  module DSL
-    # Supports between range syntax
-    module Between
-      module_function
-
-      # Creates a range that can be compared against time of day/month days or strings
-      # to see if they are within the range
-      # @since 2.4.0
-      # @return Range object representing a TimeOfDay Range
-      def between(range)
-        raise ArgumentError, 'Supplied object must be a range' unless range.is_a? Range
-
-        return OpenHAB::DSL::Between::MonthDayRange.range(range) if OpenHAB::DSL::Between::MonthDayRange.range?(range)
-
-        OpenHAB::DSL::Between::TimeOfDay.between(range)
-      end
-    end
-  end
-end

data/lib/openhab/dsl/channel.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-module OpenHAB
-  module DSL
-    java_import org.openhab.core.thing.Channel
-    java_import org.openhab.core.thing.ChannelUID
-
-    # Adds methods to core OpenHAB Channel to make it more natural in Ruby
-    class Channel
-      extend Forwardable
-
-      delegate %i[thing item items] => :uid
-    end
-
-    # Adds methods to core OpenHAB ChannelUID to make it more natural in Ruby
-    class ChannelUID
-      # Return the thing this channel is associated with.
-      #
-      # @return [Thing] The thing associated with this channel or nil
-      def thing
-        things[thing_uid]
-      end
-
-      # Return the item if this channel is linked with an item. If a channel is linked to more than one item,
-      # this method only returns the first item.
-      #
-      # @return [GenericItem] The item associated with this channel or nil
-      def item
-        items.first
-      end
-
-      # Returns all of the channel's linked items.
-      #
-      # @return [Array<GenericItem>] An array of things or an empty array
-      def items
-        registry = OpenHAB::Core::OSGI.service('org.openhab.core.thing.link.ItemChannelLinkRegistry')
-        registry.get_linked_items(self).to_a
-      end
-    end
-  end
-end

data/lib/openhab/dsl/dsl.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'imports'
-
-OpenHAB::DSL.import_presets
-
-require 'openhab/log/logger'
-
-# the order of these is important
-require_relative 'types/types'
-require_relative 'items/items'
-
-require_relative 'monkey_patch/ruby/ruby'
-require_relative 'monkey_patch/java/java'
-require_relative 'monkey_patch/events/events'
-require_relative 'monkey_patch/actions/actions'
-
-require_relative 'rules/rule'
-require_relative 'rules/terse'
-require_relative 'actions'
-require_relative 'channel'
-require_relative 'timers'
-require_relative 'group'
-require_relative 'things'
-require_relative 'between'
-require_relative 'gems'
-require_relative 'persistence'
-require_relative 'uid'
-require_relative 'units'
-require_relative 'states'
-require_relative 'openhab'
-
-module OpenHAB
-  #
-  # Module to be extended to access the OpenHAB Ruby DSL
-  #
-  module DSL
-    # Extend the calling module/class with the DSL
-    # Disabling method length because they are all includes
-    # rubocop:disable Metrics/MethodLength
-    def self.extended(base)
-      base.send :include, OpenHAB::DSL::Actions
-      base.send :include, OpenHAB::DSL::Between
-      base.send :include, OpenHAB::DSL::Core
-      base.send :include, OpenHAB::DSL::Groups
-      base.send :include, OpenHAB::DSL::Items
-      base.send :include, OpenHAB::DSL::Persistence
-      base.send :include, OpenHAB::DSL::Rules::Rule
-      base.send :include, OpenHAB::DSL::Rules::TerseRule
-      base.send :include, OpenHAB::DSL::States
-      base.send :include, OpenHAB::DSL::Things
-      base.send :include, OpenHAB::DSL::Timers
-      base.send :include, OpenHAB::DSL::Between
-      base.send :include, OpenHAB::DSL::Types
-      base.send :include, OpenHAB::DSL::Units
-    end
-    # rubocop:enable Metrics/MethodLength
-  end
-end

data/lib/openhab/dsl/group.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require 'singleton'
-
-require 'openhab/core/entity_lookup'
-require 'openhab/dsl/lazy_array'
-
-module OpenHAB
-  module DSL
-    #
-    # Provides access to OpenHAB Groups
-    #
-    module Groups
-      module_function
-
-      #
-      # Retrieve all OpenHAB groups
-      #
-      # @return [Set] of OpenHAB Groups
-      #
-      def groups
-        OpenHAB::DSL::Support::Groups.instance
-      end
-    end
-
-    module Support
-      #
-      # Provide access to groups as a set
-      #
-      class Groups
-        include LazyArray
-        include Singleton
-
-        #
-        # Get a OpenHAB Group by name
-        # @param [String] name of the group to retrieve
-        #
-        # @return [Set] of OpenHAB Groups
-        #
-        def [](name)
-          group = OpenHAB::Core::EntityLookup.lookup_item(name)
-          group.is_a?(OpenHAB::DSL::Items::GroupItem) ? group : nil
-        end
-        alias include? []
-        alias key? include?
-
-        # explicit conversion to array
-        def to_a
-          $ir.items.grep(org.openhab.core.items.GroupItem)
-        end
-      end
-    end
-  end
-end

data/lib/openhab/dsl/imports.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module OpenHAB
-  module DSL
-    include OpenHAB::Log
-    #
-    # Import required java classes
-    #
-    def self.import_presets # rubocop:disable Metrics/AbcSize
-      return if Object.const_get(:ZonedDateTime).is_a?(Class)
-
-      # Fix the import problem in OpenHAB 3.2 addon. Not required in 3.3+
-      [java.time.Duration,
-       java.time.ZonedDateTime,
-       java.time.ZoneId,
-       java.time.temporal.ChronoUnit].each do |klass|
-        Object.const_set(klass.java_class.simple_name.to_sym, klass)
-      end
-    end
-  end
-end

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

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-require_relative 'comparable_item'
-require 'openhab/dsl/types/hsb_type'
-
-module OpenHAB
-  module DSL
-    module Items
-      java_import org.openhab.core.library.items.ColorItem
-
-      # Adds methods to core OpenHAB ColorItem type to make it more natural in
-      # Ruby
-      class ColorItem < DimmerItem
-        extend Forwardable
-        include ComparableItem
-
-        # !@visibility private
-        def ==(other)
-          # need to check if we're referring to the same item before
-          # forwarding to <=> (and thus checking equality with state)
-          return true if equal?(other) || eql?(other)
-
-          super
-        end
-
-        #
-        # Type Coercion
-        #
-        # Coerce object to a HSBType
-        #
-        # @param [Types::HSBType, String] other object to coerce to a
-        #   HSBType
-        #
-        # @return [[Types::HSBType, Types::HSBType]]
-        #
-        def coerce(other)
-          logger.trace("Coercing #{self} as a request from #{other.class}")
-          return [other, nil] unless state?
-          return [other, state] if other.is_a?(Types::HSBType) || other.respond_to?(:to_str)
-        end
-
-        # any method that exists on {Types::HSBType} gets forwarded to +state+
-        delegate (Types::HSBType.instance_methods - instance_methods) => :state
-
-        # string commands aren't allowed on ColorItems, so try to implicitly
-        # convert it to an HSBType
-        # @!visibility private
-        def format_type(command)
-          return format_hash(command.to_hash) if command.respond_to?(:to_hash)
-          return Types::HSBType.new(command) if command.respond_to?(:to_str)
-
-          super
-        end
-
-        private
-
-        # Mapping of hash values sets to conversion methods
-        HASH_KEYS = { %i[r g b] => :from_rgb,
-                      %i[red green blue] => :from_rgb,
-                      %i[h s b] => :from_hsb,
-                      %i[hue saturation brightness] => :from_hsb }.freeze
-
-        def format_hash(hash)
-          hash = hash.transform_keys(&:to_sym)
-          HASH_KEYS.each do |key_set, method|
-            values = hash.values_at(*key_set).compact
-            return Types::HSBType.public_send(method, *values) if values.length == 3
-          end
-          raise ArgumentError, "Supplied hash (#{hash}) must contain one of the following keysets #{keys.keys}"
-        end
-      end
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module OpenHAB
-  module DSL
-    module Items
-      # Mixin for implementing the comparison operator for Item types that
-      # support it
-      module ComparableItem
-        #
-        # Comparison
-        #
-        # @param [GenericItem, Types::Type, Object, GenericItemObject] other object to
-        #   compare to
-        #
-        #   When comparing GenericItemObject on either side, perform object comparison
-        #   return 0 if the object is equal, or nil otherwise.
-        #
-        #   If this item is +NULL+ or +UNDEF+, and +other+ is nil, they are
-        #   considered equal
-        #
-        #   If this item is +NULL+ or +UNDEF+, and other is a {GenericItem}, they
-        #   are only considered equal if the other item is in the exact same
-        #   state (i.e. +NULL+ != +UNDEF+)
-        #
-        #   Otherwise, the state of this item is compared with +other+
-        #
-        # @return [Integer, nil] -1, 0, +1 depending on whether +other+ is
-        #   less than, equal to, or greater than self
-        #
-        #   nil is returned if the two values are incomparable
-        #
-        def <=>(other)
-          logger.trace("(#{self.class}) #{self} <=> #{other} (#{other.class})")
-
-          if is_a?(OpenHAB::DSL::GenericItemObject) || other.is_a?(OpenHAB::DSL::GenericItemObject)
-            return eql?(other) ? 0 : nil
-          end
-
-          # if we're NULL or UNDEF, implement special logic
-          return nil_comparison(other) unless state?
-
-          # delegate to how the state compares to the other object
-          state <=> other
-        end
-
-        # Special logic for NULL/UNDEF state comparison
-        # @!visibility private
-        def nil_comparison(other)
-          # if comparing to nil, consider ourselves equal
-          return 0 if other.nil?
-
-          # if the other object is an Item, only consider equal if we're
-          # in the same _kind_ of UnDefType state
-          return raw_state == other.raw_state if other.is_a?(GenericItem) && !other.state?
-
-          # otherwise, it's a non-nil thing comparing to nil, which is undefined
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module OpenHAB
-  module DSL
-    #
-    # Patches OpenHAB items
-    #
-    module Items
-      java_import org.openhab.core.library.items.ContactItem
-
-      # Alias class for ContactItem
-      ::Contact = ContactItem
-
-      # Adds methods to core OpenHAB ContactItem type to make it more natural
-      # in Ruby
-      class ContactItem < GenericItem
-        remove_method :==
-
-        #
-        # Return the inverted state of the contact: +CLOSED+ if the contact is
-        # +OPEN+, +UNDEF+ or +NULL+; +OPEN+ if the contact is +CLOSED+
-        #
-        # @return [Types::OpenClosedType] Inverted state
-        #
-        def !
-          return !state if state?
-
-          CLOSED
-        end
-
-        # @!method open?
-        #   Check if the item state == +OPEN+
-        #   @return [Boolean]
-
-        # @!method closed?
-        #   Check if the item state == +CLOSED+
-        #   @return [Boolean]
-      end
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-require 'time'
-require 'java'
-
-require 'openhab/dsl/items/comparable_item'
-
-module OpenHAB
-  module DSL
-    module Items
-      java_import org.openhab.core.library.items.DateTimeItem
-      java_import java.time.format.DateTimeFormatter
-
-      # Adds methods to core OpenHAB DateTimeItem type to make it more natural
-      # in Ruby
-      class DateTimeItem < GenericItem
-        extend Forwardable
-        include Comparable
-        include ComparableItem
-
-        # !@visibility private
-        def ==(other)
-          # need to check if we're referring to the same item before
-          # forwarding to <=> (and thus checking equality with state)
-          return true if equal?(other) || eql?(other)
-
-          super
-        end
-
-        #
-        # Type Coercion
-        #
-        # Coerce object to a DateTimeType
-        #
-        # @param [Types::DateTimeType, Time] other object to coerce to a
-        #   DateTimeType
-        #
-        # @return [[Types::DateTimeType, Types::DateTimeType]]
-        #
-        def coerce(other)
-          logger.trace("Coercing #{self} as a request from #{other.class}")
-          return [other, nil] unless state?
-          return [other, state] if other.is_a?(Types::DateTimeType) || other.respond_to?(:to_time)
-        end
-
-        # any method that exists on DateTimeType, Java's ZonedDateTime, or
-        # Ruby's Time class gets forwarded to state (which will forward as
-        # necessary)
-        delegate ((Types::DateTimeType.instance_methods +
-          java.time.ZonedDateTime.instance_methods +
-          Time.instance_methods) - instance_methods) => :state
-
-        # Time types need formatted as ISO8601
-        # @!visibility private
-        def format_type(command)
-          return command.iso8601 if command.respond_to?(:iso8601)
-          return DateTimeFormatter::ISO_OFFSET_DATE_TIME.format(command) if command.is_a? java.time.ZonedDateTime
-
-          super
-        end
-      end
-    end
-  end
-end