openhab-jrubyscripting 5.0.0.rc1

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "generic_item"
+
+module OpenHAB
+  module Core
+    module Items
+      java_import org.openhab.core.library.items.StringItem
+
+      #
+      # A {StringItem} can be used for any kind of string to either send or
+      # receive from a device.
+      #
+      # @!attribute [r] state
+      #   @return [StringType, nil]
+      #
+      # @example
+      #   # StringOne has a current state of "Hello"
+      #   StringOne << StringOne + " World!"
+      #   # StringOne will eventually have a state of 'Hello World!'
+      #
+      class StringItem < GenericItem
+      end
+    end
+  end
+end
+
+# @!parse StringItem = OpenHAB::Core::Items::StringItem

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "generic_item"
+
+module OpenHAB
+  module Core
+    module Items
+      java_import org.openhab.core.library.items.SwitchItem
+
+      #
+      # A SwitchItem represents a normal switch that can be ON or OFF.
+      # Useful for normal lights, presence detection etc.
+      #
+      # @!attribute [r] state
+      #   @return [OnOffType, nil]
+      #
+      #
+      # @example Turn on all switches in a `Group:Switch` called Switches
+      #   Switches.on
+      #
+      # @example Turn on all switches in a group called Switches that are off
+      #   Switches.select(&:off?).each(&:on)
+      #
+      # @example Switches accept booelan commands (true/false)
+      #   # Turn on switch
+      #   SwitchItem << true
+      #
+      #   # Turn off switch
+      #   SwitchItem << false
+      #
+      #   # Turn off switch if any in another group is on
+      #   SwitchItem << Switches.any?(&:on?)
+      #
+      # @example Invert all Switches
+      #   items.grep(SwitchItem)
+      #        .each(&:toggle)
+      #
+      class SwitchItem < GenericItem
+        # Convert boolean commands to ON/OFF
+        # @!visibility private
+        def format_type(command)
+          return Types::OnOffType.from(command) if [true, false].include?(command)
+
+          super
+        end
+
+        #
+        # Send a command to invert the state of the switch
+        #
+        # @return [self]
+        #
+        def toggle
+          return on unless state?
+
+          command(!state)
+        end
+
+        # @!method on?
+        #   Check if the item state == {ON}
+        #   @return [true,false]
+
+        # @!method off?
+        #   Check if the item state == {OFF}
+        #   @return [true,false]
+
+        # @!method on
+        #   Send the {ON} command to the item
+        #   @return [SwitchItem] `self`
+
+        # @!method off
+        #   Send the {OFF} command to the item
+        #   @return [SwitchItem] `self`
+      end
+    end
+  end
+end
+
+# @!parse SwitchItem = OpenHAB::Core::Items::SwitchItem

data/lib/openhab/core/items.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "types"
+
+Dir[File.expand_path("items/*.rb", __dir__)].sort.each do |f|
+  require f
+end
+
+module OpenHAB
+  module Core
+    #
+    # Contains the core types that OpenHAB uses to represent items.
+    # Items have states from the {Types} module.
+    #
+    # You may use an item or group name anywhere {DSL} (or just {Core::EntityLookup})
+    # is available, and it will automatically be loaded.
+    #
+    module Items
+      class << self
+        # Imports all of the item classes into the global namespace
+        # for convenient access.
+        def import_into_global_namespace
+          concrete_item_classes.each do |k|
+            const_name = k.java_class.simple_name
+            Object.const_set(const_name, k) unless Object.const_defined?(const_name)
+          end
+          Object.const_set(:GenericItem, GenericItem) unless Object.const_defined?(:GenericItem)
+        end
+
+        private
+
+        # takes an array of Type java classes and returns
+        # all the Enum values, in a flat array
+        def values_for_enums(enums)
+          enums.map(&:ruby_class)
+               .select { |k| k < java.lang.Enum }
+               .flat_map(&:values)
+        end
+
+        # define predicates for checking if an item is in one of the Enum states
+        def def_predicate_methods(klass)
+          values_for_enums(klass.ACCEPTED_DATA_TYPES).each do |state|
+            _command_predicate, state_predicate = Types::PREDICATE_ALIASES[state.to_s]
+            next if klass.instance_methods.include?(state_predicate)
+
+            logger.trace("Defining #{klass}##{state_predicate} for #{state}")
+            klass.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def #{state_predicate}   # def on?
+                raw_state == #{state}  #   raw_state == ON
+              end                      # end
+            RUBY
+          end
+        end
+
+        # define methods for commanding an item to one of the Enum states
+        # as well as predicates for if an ItemCommandEvent is one of those commands
+        def def_command_methods(klass)
+          values_for_enums(klass.ACCEPTED_COMMAND_TYPES).each do |value|
+            command = Types::COMMAND_ALIASES[value.to_s]
+            next if klass.instance_methods.include?(command)
+
+            logger.trace("Defining #{klass}##{command} for #{value}")
+            klass.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def #{command}(for: nil, on_expire: nil, &block)                                          # def on(for: nil, on_expire: nil, &block )
+                command(#{value}, for: binding.local_variable_get(:for), on_expire: on_expire, &block)  #   command(ON, for: nil, expire: nil, &block)
+              end                                                                                       # end
+            RUBY
+
+            logger.trace("Defining Enumerable##{command} for #{value}")
+            Enumerable.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def #{command}        # def on
+                each(&:#{command})  #   each(&:on)
+              end                   # end
+            RUBY
+
+            # Override the inherited methods from Enumerable and send it to the base_item
+            GroupItem.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def #{command}                 # def on
+                method_missing(:#{command})  #   method_missing(:on)
+              end                            # end
+            RUBY
+
+            logger.trace("Defining ItemCommandEvent##{command}? for #{value}")
+            Events::ItemCommandEvent.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def #{command}?        # def refresh?
+                command == #{value}  #   command == REFRESH
+              end                    # end
+            RUBY
+          end
+        end
+
+        def concrete_item_classes
+          constants.map { |c| const_get(c) }
+                   .grep(Module)
+                   .select { |k| k < GenericItem }
+        end
+      end
+
+      # sort classes by hierarchy so we define methods on parent classes first
+      constants.map { |c| const_get(c) }
+               .grep(Module)
+               .select { |k| k <= GenericItem && k != GroupItem && k != StringItem }
+               .sort { |a, b| a < b ? 1 : -1 }
+               .each do |klass|
+        klass.field_reader :ACCEPTED_COMMAND_TYPES, :ACCEPTED_DATA_TYPES unless klass == GenericItem
+
+        def_predicate_methods(klass)
+        def_command_methods(klass)
+      end
+
+      prepend_accepted_data_types
+    end
+  end
+end

data/lib/openhab/core/lazy_array.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    # Common base class for array-like collections that have lookup
+    # methods to avoid instantiating the elements if you only use
+    # the lookup method
+    #
+    # your class should implement to_a
+    #
+    module LazyArray
+      include Enumerable
+
+      # @!visibility private
+      def self.included(klass)
+        klass.undef_method :inspect
+        klass.undef_method :to_s
+      end
+
+      # Calls the given block once for each object, passing that object as a
+      # parameter. Returns self.
+      #
+      # If no block is given, an Enumerator is returned.
+      def each(&block)
+        to_a.each(&block)
+        self
+      end
+
+      # Implicitly convertible to array
+      #
+      # @return [Array]
+      #
+      def to_ary
+        to_a
+      end
+
+      # Delegate any other methods to the actual array, exclude mutating methods
+      def method_missing(method, *args, &block)
+        return to_a.send(method, *args, &block) if method[-1] != "!" && Array.instance_methods.include?(method)
+
+        super
+      end
+
+      # @!visibility private
+      def respond_to_missing?(method, include_private = false)
+        return true if method[-1] != "!" && Array.instance_methods.include?(method.to_sym)
+
+        super
+      end
+    end
+  end
+end

data/lib/openhab/core/profile_factory.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+require_relative "script_handling"
+
+module OpenHAB
+  module Core
+    # @!visibility private
+    class ProfileFactory
+      include org.openhab.core.thing.profiles.ProfileFactory
+      include Singleton
+
+      # rubocop:disable Naming/MethodName
+      class Profile
+        include org.openhab.core.thing.profiles.StateProfile
+
+        def initialize(callback, context, uid, thread_locals, block)
+          unless callback.class.ancestors.include?(Things::ProfileCallback)
+            callback.class.prepend(Things::ProfileCallback)
+            callback.class.field_reader :link
+          end
+
+          @callback = callback
+          @context = context
+          @uid = uid
+          @thread_locals = thread_locals
+          @block = block
+        end
+
+        # @!visibility private
+        def getProfileTypeUID
+          @uid
+        end
+
+        # @!visibility private
+        def onCommandFromItem(command)
+          return unless process_event(:command_from_item, command: command) == true
+
+          logger.trace("Forwarding original command")
+          @callback.handle_command(command)
+        end
+
+        # @!visibility private
+        def onStateUpdateFromHandler(state)
+          return unless process_event(:state_from_handler, state: state) == true
+
+          logger.trace("Forwarding original update")
+          @callback.send_update(state)
+        end
+
+        # @!visibility private
+        def onCommandFromHandler(command)
+          return unless process_event(:command_from_handler, command: command) == true
+
+          logger.trace("Forwarding original command")
+          callback.send_command(command)
+        end
+
+        # @!visibility private
+        def onStateUpdateFromItem(state)
+          process_event(:state_from_item, state: state)
+        end
+
+        private
+
+        def process_event(event, **params)
+          logger.trace("Handling event #{event.inspect} in profile #{@uid} with param #{params.values.first.inspect}.")
+
+          params[:callback] = @callback
+          params[:context] = @context
+          params[:config] = @context.configuration
+          params[:link] = @callback.link
+          params[:item] = @callback.link.item
+          params[:channel_uid] = @callback.link.linked_uid
+
+          kwargs = {}
+          @block.parameters.each do |(param_type, name)|
+            case param_type
+            when :keyreq, :key
+              kwargs[name] = params[name] if params.key?(name)
+            when :keyrest
+              kwargs = params
+            end
+          end
+
+          DSL::ThreadLocal.thread_local(**@thread_locals) do
+            @block.call(event, **kwargs)
+          rescue Exception => e
+            @block.binding.eval("self").logger.log_exception(e)
+          end
+        end
+      end
+      private_constant :Profile
+      # rubocop:enable Naming/MethodName
+
+      def initialize
+        @profiles = {}
+      end
+
+      # @!visibility private
+      def register(uid, block)
+        @profiles[uid] = [DSL::ThreadLocal.persist, block]
+      end
+
+      def createProfile(type, callback, context) # rubocop:disable Naming/MethodName
+        @profiles[type].then { |(thread_locals, block)| Profile.new(callback, context, type, thread_locals, block) }
+      end
+
+      def getSupportedProfileTypeUIDs # rubocop:disable Naming/MethodName
+        @profiles.keys
+      end
+    end
+
+    registration = OSGi.register_service(ProfileFactory.instance)
+    ScriptHandlingCallbacks.script_unloaded_hooks << -> { registration.unregister }
+  end
+end

data/lib/openhab/core/script_handling.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    #
+    # Manages script loading and unloading
+    #
+    # @!visibility private
+    module ScriptHandlingCallbacks
+      class << self
+        #
+        # Return script_loaded_hooks
+        #
+        # @!visibility private
+        def script_loaded_hooks
+          @script_loaded_hooks ||= []
+        end
+
+        #
+        # Return script_unloaded_hooks
+        #
+        # @!visibility private
+        def script_unloaded_hooks
+          @script_unloaded_hooks ||= []
+        end
+      end
+
+      #
+      # Executed when OpenHAB unloads a script file
+      #
+      def scriptUnloaded # rubocop:disable Naming/MethodName method name dictated by OpenHAB
+        logger.trace("Script unloaded")
+        ScriptHandlingCallbacks.script_unloaded_hooks.each do |hook|
+          hook.call
+        rescue => e
+          logger.error("Failed to call script_unloaded hook #{hook}: #{e}")
+        end
+      end
+
+      #
+      # Executed when OpenHAB loads a script file
+      #
+      def scriptLoaded(filename) # rubocop:disable Naming/MethodName method name dictated by OpenHAB
+        logger.trace("Script loaded: #{filename}")
+        ScriptHandlingCallbacks.script_loaded_hooks.each do |hook|
+          hook.call
+        rescue => e
+          logger.error("Failed to call script_loaded hook #{hook}: #{e}")
+        end
+      end
+    end
+  end
+end
+
+singleton_class.include(OpenHAB::Core::ScriptHandlingCallbacks)

data/lib/openhab/core/things/channel.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module OpenHAB
+  module Core
+    module Things
+      java_import org.openhab.core.thing.Channel
+
+      #
+      # {Channel} is a part of a {Thing} that represents a functionality of it.
+      # Therefore {GenericItem Items} can be linked a to a channel.
+      #
+      # @!attribute [r] item
+      #   (see ChannelUID#item)
+      #
+      # @!attribute [r] items
+      #   (see ChannelUID#items)
+      #
+      # @!attribute [r] thing
+      #   (see ChannelUID#thing)
+      #
+      # @!attribute [r] uid
+      #   @return [ChannelUID]
+      #
+      class Channel
+        extend Forwardable
+
+        delegate %i[item items thing] => :uid
+
+        # @return [String]
+        def inspect
+          r = "#<OpenHAB::Core::Things::Channel #{uid}"
+          r += " #{label.inspect}" if label
+          r += " auto_update_policy=#{auto_update_policy}" if auto_update_policy
+          r += " configuration=#{configuration.properties.to_h}" unless configuration.properties.empty?
+          r += " properties=#{properties.to_h}" unless properties.empty?
+          "#{r}>"
+        end
+
+        # @return [String]
+        def to_s
+          uid.to_s
+        end
+      end
+    end
+  end
+end

data/lib/openhab/core/things/channel_uid.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module OpenHAB
+  module Core
+    module Things
+      java_import org.openhab.core.thing.ChannelUID
+
+      #
+      # {ChannelUID} represents a unique identifier for {Channel channels}.
+      #
+      class ChannelUID
+        #
+        # @attribute [r] thing
+        #
+        # Return the thing this channel is associated with.
+        #
+        # @return [Thing, nil]
+        #
+        def thing
+          EntityLookup.lookup_thing(thing_uid)
+        end
+
+        #
+        # @attribute [r] item
+        #
+        # 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, nil]
+        #
+        def item
+          items.first
+        end
+
+        #
+        # @attribute [r] items
+        #
+        # Returns all of the channel's linked items.
+        #
+        # @return [Array<GenericItem>] An array of things or an empty array
+        #
+        def items
+          registry = OSGi.service("org.openhab.core.thing.link.ItemChannelLinkRegistry")
+          registry.get_linked_items(self).map { |i| Items::Proxy.new(i) }
+        end
+      end
+    end
+  end
+end

data/lib/openhab/core/things/item_channel_link.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    module Things
+      java_import org.openhab.core.thing.link.ItemChannelLink
+
+      #
+      # Represents the link between a {GenericItem} and a {Thing Thing's}
+      # {Channel}.
+      #
+      # @!attribute [r] thing
+      #   @return [Thing]
+      #
+      # @!attribute [r] channel_uid
+      #   @return [ChannelUID]
+      #
+      class ItemChannelLink
+        extend Forwardable
+
+        def_delegator :linked_uid, :thing
+
+        # @!attribute [r] item
+        # @return [GenericItem]
+        def item
+          DSL.items[item_name]
+        end
+
+        alias_method :channel_uid, :linked_uid
+      end
+    end
+  end
+end

data/lib/openhab/core/things/profile_callback.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    module Things
+      #
+      # Contains methods for {OpenHAB::DSL.profile profile}'s callback to forward commands between items
+      # and channels.
+      #
+      module ProfileCallback
+        class << self
+          #
+          # Wraps the parent class's method to format non-Types.
+          #
+          # @!macro def_state_parsing_method
+          #   @!method $1($2)
+          #   @return [void]
+          # @!visibility private
+          def def_state_parsing_method(method, param_name)
+            class_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def #{method}(type)                                                             # def handle_command(type)
+                type = link.item.format_#{param_name == :state ? :update : param_name}(type)  #   type = link.item.format_command(type)
+                super(type)                                                                   #   super(type)
+              end                                                                             # end
+            RUBY
+          end
+        end
+
+        #
+        # Forward the given command to the respective thing handler.
+        #
+        # @param [Command] command
+        #
+        def_state_parsing_method(:handle_command, :command)
+
+        #
+        # Send a command to the framework.
+        #
+        # @param [Command] command
+        #
+        def_state_parsing_method(:send_command, :command)
+
+        #
+        # Send a state update to the framework.
+        #
+        # @param [State] state
+        #
+        def_state_parsing_method(:send_update, :state)
+      end
+    end
+  end
+end

data/lib/openhab/core/things/proxy.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "delegate"
+require "forwardable"
+
+module OpenHAB
+  module Core
+    module Things
+      # Class is a proxy to underlying thing
+      # @!visibility private
+      class Proxy < Delegator
+        extend Forwardable
+        def_delegators :__getobj__, :class, :is_a?, :kind_of?
+
+        # Returns the list of channels associated with this Thing
+        #
+        # @note This is defined on this class, and not on {Thing}, because
+        #   that's the interface and if you define it there, it will be hidden
+        #   by the method on ThingImpl.
+        #
+        # @return [Array] channels
+        def channels
+          Thing::ChannelsArray.new(super.to_a)
+        end
+
+        #
+        # Set the proxy item (called by super)
+        #
+        def __setobj__(thing)
+          @uid = thing.uid
+        end
+
+        #
+        # Lookup thing from thing registry
+        #
+        def __getobj__
+          $things.get(@uid)
+        end
+
+        #
+        # Need to check if `self` _or_ the delegate is an instance of the
+        # given class
+        #
+        # So that {#==} can work
+        #
+        # @return [true, false]
+        #
+        # @!visibility private
+        def instance_of?(klass)
+          __getobj__.instance_of?(klass) || super
+        end
+
+        #
+        # Check if delegates are equal for comparison
+        #
+        # Otherwise items can't be used in Java maps
+        #
+        # @return [true, false]
+        #
+        # @!visibility private
+        def ==(other)
+          return __getobj__ == other.__getobj__ if other.instance_of?(Proxy)
+
+          super
+        end
+      end
+    end
+  end
+end