openhab-scripting 5.35.1 → 5.36.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b21b40668410811b84a0ffeb8e4e8f1538d9fe8ba546dbdc8c9a4e4b70a0f245
-  data.tar.gz: d521f1f642bd2d96e9dea0fab156f3120eadb4004579770d4d49d3d6ca5f700b
+  metadata.gz: f198e81a6fc5f5fa47a8a9ac4ac64e4749e64b94edb36771859bebdab249af0a
+  data.tar.gz: a1ab30b88528a5571f23e9ba0583a18821110c3f2bbfe1741e4bfe51ba819f36
 SHA512:
-  metadata.gz: 48a66dcc913693a3e00cbed821168c4c3ee5d2404775d9bc939f7e79026056714db6abbb049bbf361b1afbac9539eaaab2bc9d5ba000a7ccfc3ee9ab61b00443
-  data.tar.gz: cdb4a5702f8e8b7f39768e0c0718781cda73a5849e86171860b2906e1c46bc7792ba0ebd7245dcf24b50e317606382e54e62aa54d676fb8c2ef359f83cdef5cb
+  metadata.gz: 52404aa905b6e01c85350b714c8b4ee92f7aed669e28fb7502064ac86fa2a46833830eeb76a8f1055e5ebd51b22c2b0941bb1b6b548f11ef363bea5f080c99d9
+  data.tar.gz: ac2c7fc1e398ac72b36f63e83601ab3889570c9b759f218e3ef3a9421c71e92854ec5d2c2cde2053ea2de5bf96232c3dc2c0138690400c1187ed03799a6f9682

data/lib/openhab/console/irb.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "openhab/console/stdio"
+
+gem "irb", "~> 1.15"
+
+require "irb"
+
+module OpenHAB
+  # @!visibility private
+  module Console
+    module IRB
+      class Exit < Exception; end # rubocop:disable Lint/InheritException
+
+      module Irb
+        # Define #exit instead of using Kernel#exit, to raise an error if we're not
+        # on the main thread (i.e. in the signal handler)
+        def exit
+          raise Exit unless Thread.current == context.thread
+
+          super
+        end
+
+        # Define #trap instead of using Kernel#trap, so that we register a signal handler against JLine.
+        # It can also never be as effective, since it's an SSH session, not a true signal, and thus it
+        # comes in as part of the input stream, and if we're not actively reading the input stream (cause
+        # we're executing a blocking Ruby method), we won't see it to be able to interrupt the Ruby code.
+        def trap(signal, handler = nil)
+          jline_signal = org.jline.terminal.Terminal::Signal.const_get(signal.sub(/^SIG/, ""), false)
+          return $terminal.handle(jline_signal, handler) if handler
+
+          $terminal.handle(jline_signal) do
+            yield
+          rescue StandardError, Exit => e
+            context.thread.raise e
+          end
+        end
+      end
+      ::IRB::Irb.include(Irb)
+
+      module StdioInputMethod
+        # make sure we use our replacement stdio streams, and not the
+        # re-opened ones based on STDIN/STDOUT
+        def initialize
+          super
+
+          @stdin = $stdin
+          @stdout = $stdout
+        end
+      end
+      ::IRB::StdioInputMethod.prepend(StdioInputMethod)
+      [::IRB::ReadlineInputMethod, ::IRB::RelineInputMethod].each do |klass|
+        klass.include(StdioInputMethod)
+      end
+
+      module ReadlineInputMethod
+        def initialize
+          super
+
+          $terminal.echo_enabled = false
+        end
+      end
+      ::IRB::ReadlineInputMethod.prepend(ReadlineInputMethod)
+
+      module EntityCompletor
+        VALID_ENTITY_PREFIXES = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_"
+
+        def completion_candidates(_preposing, target, _postposing, bind:)
+          return super unless defined?(OpenHAB::Core::EntityLookup)
+          return super unless VALID_ENTITY_PREFIXES.include?(target[0])
+
+          this = bind.eval("self")
+          return super unless this.is_a?(OpenHAB::Core::EntityLookup)
+
+          matching_items = OpenHAB::DSL.items.filter_map do |item|
+            item.name if item.name.start_with?(target)
+          end
+          matching_things = OpenHAB::DSL.things.filter_map do |thing|
+            id = thing.uid.to_s.tr(":", "_")
+            id if id.start_with?(target)
+          end
+          matching_items | matching_things | super
+        end
+      end
+      ::IRB::RegexpCompletor.prepend(EntityCompletor)
+      ::IRB::TypeCompletor.prepend(EntityCompletor)
+    end
+  end
+end
+
+# disable Reline for now; it's not working
+IRB.conf[:USE_MULTILINE] = false
+# Uncomment to disable Readline and force StdioInputMethod
+# IRB.conf[:USE_SINGLELINE] = false
+
+# IRB uses Reline to find the window size initially, even if it's not
+# using the Reline input method
+Reline.input = $stdin
+Reline.output = $stdout
+
+begin
+  IRB.start("karaf")
+rescue OpenHAB::Console::IRB::Exit
+  exit
+end

data/lib/openhab/console/jline.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "openhab/console/stdio"
+
+module OpenHAB
+  module Console
+    #
+    # A basic JRuby REPL for openHAB Karaf console
+    #
+    # To use this, set the jrubyscripting add-on `console` configuration to `jline`
+    #
+    class JLine
+      # Create constants instead of java_import to avoid polluting the global namespace
+      LineReader = org.jline.reader.LineReader
+      Bracket = org.jline.reader.impl.DefaultParser::Bracket
+
+      BOLD = "\e[1m"
+      RESET = "\e[0m"
+      RED = "\e[31m"
+      GREEN = "\e[32m"
+      YELLOW = "\e[33m"
+      BLUE = "\e[34m"
+      CYAN = "\e[36m"
+
+      ERROR = RED
+      STRING = BOLD + YELLOW
+      NUMBER = BOLD + BLUE
+      OBJECT = BOLD + GREEN
+      SIMPLE_CLASS = BOLD + CYAN
+      PROMPT = "#{BOLD}JRuby> #{RESET}".freeze
+
+      class << self
+        def start
+          puts "Welcome to JRuby REPL. Press Ctrl+D to exit, Alt+Enter (or Esc,Enter) to insert a new line."
+
+          console = new
+
+          loop do
+            begin
+              input = console.read_line
+              next if input.strip.empty?
+            rescue org.jline.reader.UserInterruptException # Ctrl+C is pressed
+              next
+            rescue org.jline.reader.EndOfFileException # Ctrl+D is pressed
+              break
+            end
+
+            begin
+              # Use TOPLEVEL_BINDING to isolate and keep the local variables between loops
+              result = TOPLEVEL_BINDING.eval(input)
+              console.print_result(result)
+            rescue Exception => e
+              console.print_error(e)
+            end
+          end
+        end
+      end
+
+      def initialize
+        parser = org.jline.reader.impl.DefaultParser.new
+                    .eof_on_unclosed_bracket(Bracket::CURLY, Bracket::ROUND, Bracket::SQUARE)
+                    .eof_on_unclosed_quote(true)
+                    .eof_on_escaped_new_line(true)
+
+        completer =
+          org.jline.reader.Completer.impl do |_method_name, _reader, _line, candidates|
+            sources = TOPLEVEL_BINDING.local_variables + Object.constants
+            sources += DSL.items.map(&:name) + DSL.methods(false) if defined?(DSL)
+
+            candidates.add_all(sources.map { |c| org.jline.reader.Candidate.new(c.to_s) })
+          end
+
+        @reader = org.jline.reader.LineReaderBuilder.builder
+                     .terminal($terminal)
+                     .app_name("jrubyscripting")
+                     .parser(parser)
+                     .completer(completer)
+                     .variable(LineReader::SECONDARY_PROMPT_PATTERN, "%M%P > ")
+                     .variable(LineReader::INDENTATION, 2)
+                     .build
+      end
+
+      def read_line
+        @reader.read_line(PROMPT)
+      end
+
+      def print_result(result)
+        puts "=> " + # rubocop:disable Style/StringConcatenation
+             case result
+             when nil, true, false then SIMPLE_CLASS + result.inspect + RESET
+             when String then %("#{STRING}#{result.dump[1..-2]}#{RESET}")
+             when Numeric, Array, Hash then NUMBER + result.to_s + RESET
+             else OBJECT + result.inspect + RESET
+             end
+      end
+
+      def print_error(error)
+        puts ERROR + "Error: #{error.message}" + RESET
+      end
+    end
+  end
+end
+
+OpenHAB::Console::JLine.start

data/lib/openhab/console/registry.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# This provides the list for the `jrubyscripting console --list` command
+module OpenHAB
+  module Console
+    # The keys are the names of the file to be required
+    REGISTRY = {
+      jline: "A basic JRuby REPL",
+      irb: "IRB console"
+    }.freeze
+  end
+end

data/lib/openhab/console/stdio.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "openhab/console"
+require "stringio"
+
+module OpenHAB
+  # @!visibility private
+  module Console
+    class Stdio
+      attr_reader :internal_encoding
+
+      def initialize(terminal)
+        @terminal = terminal
+        @external_encoding = Encoding.find(@terminal.encoding.name)
+      end
+
+      def set_encoding(_external, internal = nil, _options = {})
+        @internal_encoding = internal
+      end
+
+      def tty?
+        true
+      end
+
+      def winsize
+        [@terminal.width, @terminal.height]
+      end
+
+      def inspect
+        "#<#{self.class}>"
+      end
+    end
+
+    class Stdin < Stdio
+      attr_reader :external_encoding, :internal_encoding
+
+      def initialize(terminal)
+        super
+
+        @byte_stream = terminal.input
+        @buffer = StringIO.new.set_encoding(external_encoding)
+      end
+
+      def getbyte
+        unless @buffer.eof?
+          b = @buffer.getbyte
+          @buffer.truncate(0) if @buffer.eof?
+          return b
+        end
+
+        b = @byte_stream.read
+        return nil if b.negative?
+
+        b
+      end
+
+      def getc
+        unless @buffer.eof?
+          c = @buffer.getc
+          @buffer.truncate(0) if @buffer.eof?
+          return c
+        end
+        bytes = (+"").force_encoding(Encoding::BINARY)
+        loop do
+          b = getbyte
+          return nil if b.nil?
+
+          bytes << b.chr
+          c = bytes.encode(external_encoding,
+                           internal_encoding || Encoding.default_internal,
+                           invalid: :replace,
+                           undef: :replace,
+                           replace: "")
+          return c unless c.empty?
+        end
+      rescue java.io.InterruptedIOException
+        raise Interrupt
+      end
+
+      def ungetbyte(byte)
+        @buffer.ungetbyte(byte)
+      end
+
+      def ungetc(char)
+        @buffer.ungetc(char)
+      end
+
+      def gets
+        result = +""
+        loop do
+          c = getc
+          if c.nil?
+            return nil if result.empty?
+
+            break
+          end
+
+          if c == "\x04" && result.empty? # ^D
+            return nil
+          elsif c == "\x7f"
+            result.slice(0...-1)
+          else
+            result << c
+          end
+          break if c == "\n"
+        end
+        result
+      rescue java.io.InterruptedIOException
+        raise Interrupt
+      end
+
+      def read(bytes)
+        r = readpartial(bytes)
+        r.concat(readpartial(bytes - r.bytesize)) while r.bytesize < bytes
+        r
+      end
+
+      def readpartial(bytes)
+        available = @buffer.size - @buffer.tell
+        if available.positive?
+          bytes = available if available < bytes
+          r = @buffer.read(bytes)
+          @buffer.truncate(0) if @buffer.eof?
+          return r
+        end
+
+        buffer = Java::byte[bytes].new
+        read = @byte_stream.read_buffered(buffer)
+        buffer = buffer[0..read] if read != bytes
+        String.from_java_bytes(buffer)
+      end
+      alias_method :read_nonblock, :readpartial
+
+      def wait_readable(timeout = nil)
+        return true if (@buffer.size - @buffer.tell).positive?
+
+        timeout = timeout ? 0 : timeout * 1000
+        char = @byte_stream.read(timeout)
+        return nil if char.negative? # timeout
+
+        ungetc(char.chr(external_encoding))
+        self
+      end
+
+      def raw(*)
+        previous_attributes = @terminal.enter_raw_mode
+        yield self
+      ensure
+        @terminal.set_attributes(previous_attributes)
+      end
+    end
+
+    class Stdout < Stdio
+      def initialize(terminal)
+        super
+        @writer = terminal.writer
+      end
+
+      def write(output)
+        @writer.print(output)
+        @writer.flush
+      end
+      alias_method :<<, :write
+
+      def flush
+        @writer.flush
+      end
+
+      def puts(output)
+        output = output.join("\n") if output.is_a?(Array)
+        @writer.println(output.to_s)
+      end
+    end
+  end
+end
+
+$stdin = OpenHAB::Console::Stdin.new($terminal)
+$stdout = $stderr = OpenHAB::Console::Stdout.new($terminal)

data/lib/openhab/console.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+raise "#{__FILE__} is only meant to be required from the context of the Karaf console" unless $terminal
+
+ENV["TERM"] = $terminal.type

data/lib/openhab/core/emulate_hash.rb

@@ -86,16 +86,16 @@ module OpenHAB
       # java.util.Map#merge is incompatible to Ruby's, but JRuby provides #ruby_merge for it
       #
       # @!visibility private
-      def merge(*others, &block)
+      def merge(*others, &)
         return self if others.empty?
 
         others.map! { |hash| hash.transform_keys(&:to_s) }
         map = to_map
         if map.respond_to?(:ruby_merge)
-          map.ruby_merge(*others, &block)
+          map.ruby_merge(*others, &)
         else
           # fall back to #merge in case #to_map returns a Ruby Hash
-          map.merge(*others, &block)
+          map.merge(*others, &)
         end
       end
 
@@ -123,8 +123,8 @@ module OpenHAB
       end
 
       # @!visibility private
-      def fetch(key, *default, &block)
-        to_map.fetch(key.to_s, *default, &block)
+      def fetch(key, *default, &)
+        to_map.fetch(key.to_s, *default, &)
       end
 
       # @!visibility private
@@ -170,8 +170,8 @@ module OpenHAB
       end
 
       # @!visibility private
-      def keep_if(&block)
-        select!(&block)
+      def keep_if(&)
+        select!(&)
         self
       end
 
@@ -191,13 +191,13 @@ module OpenHAB
       end
 
       # @!visibility private
-      def fetch_values(*keys, &block)
-        to_map.fetch_values(*keys.map(&:to_s), &block)
+      def fetch_values(*keys, &)
+        to_map.fetch_values(*keys.map(&:to_s), &)
       end
 
       # @!visibility private
-      def transform_keys!(*args, &block)
-        replace(transform_keys(*args, &block))
+      def transform_keys!(...)
+        replace(transform_keys(...))
       end
 
       # @!visibility private

data/lib/openhab/core/entity_lookup.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "ruby2_keywords"
-
 module OpenHAB
   module Core
     #
@@ -123,7 +121,7 @@ module OpenHAB
       #
       # @return [Item, Things::Thing, nil]
       #
-      ruby2_keywords def method_missing(method, *args)
+      def method_missing(method, *args)
         return super unless args.empty? && !block_given?
 
         logger.trace { "method missing, performing openHAB Lookup for: #{method}" }
@@ -160,7 +158,7 @@ module OpenHAB
         def lookup_entity(name, create_dummy_items: false)
           # make sure we have a nil return
           create_dummy_items = nil if create_dummy_items == false
-          lookup_item(name) || lookup_thing_const(name) || (create_dummy_items && Items::Proxy.new(name.to_sym))
+          lookup_item(name) || lookup_thing_const(name) || (create_dummy_items && Items::Proxy.new(name.to_s))
         end
 
         #

data/lib/openhab/core/events/item_state_updated_event.rb

@@ -2,9 +2,6 @@
 
 require_relative "item_state_event"
 
-# @deprecated OH3.4 guard only needed in OH 3.4
-return unless OpenHAB::Core.version >= OpenHAB::Core::V4_0
-
 module OpenHAB
   module Core
     module Events

data/lib/openhab/core/events/item_time_series_updated_event.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-# @deprecated OH4.0 guard not needed in OH 4.1
-return unless OpenHAB::Core.version >= OpenHAB::Core::V4_1
-
 module OpenHAB
   module Core
     module Events

data/lib/openhab/core/events/startlevel_event.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-# @deprecated OH3.4 this guard is not needed on OH4
-return unless OpenHAB::Core.version >= OpenHAB::Core::V4_0
-
 module OpenHAB
   module Core
     module Events

data/lib/openhab/core/events/timer_event.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-# @deprecated OH3.4 this guard is not needed on OH4
-return unless OpenHAB::Core.version >= OpenHAB::Core::V4_0
-
 module OpenHAB
   module Core
     module Events