openhab-scripting 2.16.2 → 2.16.3

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

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require 'java'
-require 'delegate'
-require 'forwardable'
-
-module OpenHAB
-  module Core
-    module DSL
-      #
-      # Provides access to and ruby wrappers around OpenHAB timers
-      #
-      module Timers
-        java_import org.openhab.core.model.script.actions.ScriptExecution
-        java_import java.time.ZonedDateTime
-
-        # Ruby wrapper for OpenHAB Timer
-        # This class implements delegator to delegate methods to the OpenHAB timer
-        #
-        # @author Brian O'Connell
-        # @since 2.0.0
-        class Timer < SimpleDelegator
-          extend Forwardable
-
-          def_delegator :@timer, :is_active, :active?
-          def_delegator :@timer, :is_running, :running?
-          def_delegator :@timer, :has_terminated, :terminated?
-
-          #
-          # Create a new Timer Object
-          #
-          # @param [Duration] duration Duration until timer should fire
-          # @param [Block] block Block to execute when timer fires
-          #
-          def initialize(duration:, &block)
-            @duration = duration
-
-            # A semaphore is used to prevent a race condition in which calling the block from the timer thread
-            # occurs before the @timer variable can be set resulting in @timer being nil
-            semaphore = Mutex.new
-
-            timer_block = proc { semaphore.synchronize { block.call(self) } }
-
-            semaphore.synchronize do
-              @timer = ScriptExecution.createTimer(
-                ZonedDateTime.now.plus(@duration), timer_block
-              )
-              super(@timer)
-            end
-          end
-
-          #
-          # Reschedule timer
-          #
-          # @param [Duration] duration
-          #
-          # @return [<Type>] <description>
-          #
-          def reschedule(duration = nil)
-            duration ||= @duration
-            @timer.reschedule(ZonedDateTime.now.plus(duration))
-          end
-        end
-
-        #
-        # Execute the supplied block after the specified duration
-        #
-        # @param [Duration] duration after which to execute the block
-        # @param [Block] block to execute, block is passed a Timer object
-        #
-        # @return [Timer] Timer object
-        #
-        def after(duration, &block)
-          Timer.new(duration: duration, &block)
-        end
-      end
-    end
-  end
-end

data/lib/openhab/core/dsl/types/quantity.rb

@@ -1,292 +0,0 @@
-# frozen_string_literal: true
-
-require 'java'
-require 'forwardable'
-
-module OpenHAB
-  module Core
-    module DSL
-      #
-      # Ruby implementation of OpenHAB Types
-      #
-      module Types
-        #
-        # Ruby implementation for OpenHAB quantities
-        #
-        # rubocop: disable Metrics/ClassLength
-        # Disabled because this class has a single responsibility, there does not appear a logical
-        # way of breaking it up into multiple classes
-        class Quantity < Numeric
-          extend Forwardable
-          include Logging
-
-          def_delegator :@quantity, :to_s
-
-          java_import org.openhab.core.library.types.QuantityType
-          java_import 'tec.uom.se.format.SimpleUnitFormat'
-          java_import 'tec.uom.se.AbstractUnit'
-
-          # @return [Hash] Mapping of operation symbols to BigDecimal methods
-          OPERATIONS = {
-            '+' => 'add',
-            '-' => 'subtract',
-            '*' => 'multiply',
-            '/' => 'divide'
-          }.freeze
-
-          private_constant :OPERATIONS
-
-          attr_reader :quantity
-
-          #
-          # Create a new Quantity
-          #
-          # @param [object] quantity String,QuantityType or Numeric to be this quantity
-          #
-          # Cop disabled, case statement is compact and idiomatic
-          def initialize(quantity)
-            @quantity = case quantity
-                        when String then QuantityType.new(quantity)
-                        when QuantityType then quantity
-                        when NumberItem, Numeric then QuantityType.new(quantity.to_d.to_java, AbstractUnit::ONE)
-                        else raise ArgumentError, "Unexpected type #{quantity.class} provided to Quantity initializer"
-                        end
-            super()
-          end
-
-          #
-          # Convert this quantity into a another unit
-          #
-          # @param [Object] other String or Unit to convert to
-          #
-          # @return [Quantity] This quantity converted to another unit
-          #
-          def |(other)
-            other = SimpleUnitFormat.instance.unitFor(other) if other.is_a? String
-
-            Quantity.new(quantity.to_unit(other))
-          end
-
-          #
-          # Compare this quantity
-          #
-          # @param [Object] other object to compare to
-          #
-          # @return [Integer] -1,0,1 if this object is less than, equal to, or greater than the supplied object,
-          #   nil if it cannot be compared
-          #
-          def <=>(other)
-            logger.trace("Comparing #{self} to #{other}")
-            my_qt, other_qt = unitize(*to_qt(coerce(other).reverse))
-            my_qt.compare_to(other_qt)
-          end
-
-          #
-          # Coerce other object into a Quantity
-          #
-          # @param [Object] other object to convert to Quantity
-          #
-          # @return [Array] of self and other object as Quantity types, nil if object cannot be coerced
-          #
-          def coerce(other)
-            logger.trace("Coercing #{self} as a request from #{other.class}")
-            case other
-            when Quantity then [other.quantity, quantity]
-            when QuantityType then [other, quantity]
-            when NumberItem then [other.to_qt.quantity, quantity]
-            when Numeric, String then [Quantity.new(other), self]
-            end
-          end
-
-          #
-          # Forward missing methods to Openhab Quantity Item if they are defined
-          #
-          # @param [String] meth name of method invoked
-          # @param [Array] args arguments to invoked method
-          # @param [Proc] block block passed ot method
-          #
-          # @return [Object] result of delegation
-          #
-          def method_missing(meth, *args, &block)
-            logger.trace("Method missing, performing dynamic lookup for: #{meth}")
-            if quantity.respond_to?(meth)
-              quantity.__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
-
-          #
-          # Checks if this method responds to the missing method
-          #
-          # @param [String] method_name Name of the method to check
-          # @param [Boolean] _include_private boolean if private methods should be checked
-          #
-          # @return [Boolean] true if this object will respond to the supplied method, false otherwise
-          #
-          def respond_to_missing?(method_name, _include_private = false)
-            quantity.respond_to?(method_name) ||
-              ::Kernel.method_defined?(method_name) ||
-              ::Kernel.private_method_defined?(method_name)
-          end
-
-          #
-          # Negate the quantity
-          #
-          # @return [Quantity] This quantity negated
-          #
-          def -@
-            Quantity.new(quantity.negate)
-          end
-
-          OPERATIONS.each do |operation, method|
-            define_method(operation) do |other|
-              logger.trace("Executing math operation '#{operation}' on quantity #{inspect} "\
-                           "with other type #{other.class} and value #{other.inspect}")
-
-              a, b = to_qt(coerce(other).reverse)
-              logger.trace("Coerced a='#{a}' with b='#{b}'")
-              a, b = unitize(a, b, operation)
-              logger.trace("Unitized a='#{a}' b='#{b}'")
-              logger.trace("Performing operation '#{operation}' with method '#{method}' on a='#{a}' with b='#{b}'")
-              Quantity.new(a.public_send(method, b))
-            end
-          end
-
-          #
-          # Provide details about quantity object
-          #
-          # @return [String] Representing details about the quantity object
-          #
-          def inspect
-            if @quantity.unit == AbstractUnit::ONE
-              "unit=#{@quantity.unit}, value=#{@quantity.to_string}"
-            else
-              @quantity.to_string
-            end
-          end
-
-          private
-
-          # @return [Array] Array of strings for operations for which the operands will not be unitized
-          DIMENSIONLESS_NON_UNITIZED_OPERATIONS = %w[* /].freeze
-
-          # Dimensionless numbers should only be unitzed for addition and subtraction
-
-          #
-          # Convert one or more Quantity obects to the underlying quantitytypes
-          #
-          # @param [Array] quanities Array of either Quantity or QuantityType objects
-          #
-          # @return [Array]  Array of QuantityType objects
-          #
-          def to_qt(*quanities)
-            [quanities].flatten.compact.map { |item| item.is_a?(Quantity) ? item.quantity : item }
-          end
-
-          #
-          # Checks if an item should be unitized
-          #
-          # @param [Quantity] quantity to check
-          # @param [String] operation quantity is being used with
-          #
-          # @return [Boolean] True if the quantity should be unitzed based on the unit and operation, false otherwise
-          #
-          def unitize?(quantity, operation)
-            !(quantity.unit == AbstractUnit::ONE && DIMENSIONLESS_NON_UNITIZED_OPERATIONS.include?(operation))
-          end
-
-          #
-          # Convert the unit for the quantity
-          #
-          # @param [Quantity] quantity being converted
-          #
-          # @return [Quantity] Quantity coverted to unit set by unit block
-          #
-          def convert_unit(quantity)
-            return quantity unless unit?
-
-            case quantity.unit
-            when unit
-              quantity
-            when AbstractUnit::ONE
-              convert_unit_from_dimensionless(quantity, unit)
-            else
-              convert_unit_from_dimensioned(quantity, unit)
-            end
-          end
-
-          #
-          # Converts a dimensioned quantity to a specific unit
-          #
-          # @param [Quantity] quantity to convert
-          # @param [Unit] unit to convert to
-          #
-          # @return [Java::org::openhab::core::library::types::QuantityType] converted quantity
-          #
-          def convert_unit_from_dimensioned(quantity, unit)
-            logger.trace("Converting dimensioned item #{inspect} to #{unit}")
-            quantity.to_unit(unit).tap do |converted|
-              raise "Conversion from #{quantity.unit} to #{unit} failed" unless converted
-            end
-          end
-
-          #
-          # Converts a dimensionless quantity to a unit
-          #
-          # @param [Quantity] quantity to convert
-          # @param [Unit] unit to convert to
-          #
-          # @return [Java::org::openhab::core::library::types::QuantityType] converted quantity
-          #
-          def convert_unit_from_dimensionless(quantity, unit)
-            logger.trace("Converting dimensionless #{quantity} to #{unit}")
-            QuantityType.new(quantity.to_big_decimal, unit)
-          end
-
-          #
-          # Convert quantities to appropriate units
-          #
-          # @param [Quantity] quantity_a Quantity on left side of operation
-          # @param [Quantity] quantity_b Quantity on right side of operation
-          # @param [String] operation Math operation
-          # @yield [quantity_a, quantity_b] yields unitized versions of supplied quantities
-          #
-          # @return [Array, Object] of quantites in correct units for the supplied operation and the unit
-          #   or the result of the block if a block is given
-          #
-          def unitize(quantity_a, quantity_b, operation = nil)
-            logger.trace("Unitizing (#{quantity_a}) and (#{quantity_b})")
-            quantity_a, quantity_b = [quantity_a, quantity_b].map do |qt|
-              unitize?(qt, operation) ? convert_unit(qt) : qt
-            end
-            return yield quantity_a, quantity_b if block_given?
-
-            [quantity_a, quantity_b]
-          end
-
-          #
-          # Get the unit from the current thread local variable
-          #
-          # @return [Object] Unit or string representation of Unit, or nil if not set
-          #
-          def unit
-            Thread.current.thread_variable_get(:unit)
-          end
-
-          #
-          # Is a unit set for this thread
-          #
-          # @return [boolean] true if a unit is set by this thread, false otherwise
-          #
-          def unit?
-            unit != nil
-          end
-        end
-      end
-    end
-  end
-end
-# rubocop: enable Metrics/ClassLength

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require 'java'
-
-# Import Imperial and SI Units overriding provided values
-%i[ImperialUnits SIUnits].each do |type|
-  Object.send(:remove_const, type)
-  java_import "org.openhab.core.library.unit.#{type}"
-end
-
-Object.send(:remove_const, :QuantityType)
-java_import org.openhab.core.library.types.QuantityType
-
-module OpenHAB
-  module Core
-    module DSL
-      #
-      # Provides support for interacting with OpenHAB Units of Measurement
-      #
-      module Units
-        java_import 'tec.uom.se.format.SimpleUnitFormat'
-
-        #
-        # Sets a thread local variable to the supplied unit such that classes operating inside the block
-        # can perform automatic conversions to the supplied unit for NumberItems
-        #
-        # @param [Object] unit OpenHAB Unit or String representing unit
-        # @yield [] Block executed in context of the supplied unit
-        #
-        #
-        def unit(unit)
-          unit = SimpleUnitFormat.instance.unitFor(unit) if unit.is_a? String
-          Thread.current.thread_variable_set(:unit, unit)
-          yield
-        ensure
-          Thread.current.thread_variable_set(:unit, nil)
-        end
-      end
-    end
-  end
-end

data/lib/openhab/core/log.rb

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-
-require 'openhab/configuration'
-require 'java'
-require 'pp'
-
-#
-# Provides access to the OpenHAB logging using a Ruby logging methods
-#
-module Logging
-  #
-  # Ruby Logger that forwards messages at appropriate levels to OpenHAB Logger
-  #
-  class Logger
-    java_import org.slf4j.LoggerFactory
-
-    # @return [Array] Supported logging levels
-    LEVELS = %i[TRACE DEBUG WARN INFO ERROR].freeze
-
-    #
-    # Create a new logger
-    #
-    # @param [String] name of the logger
-    #
-    def initialize(name)
-      @sl4fj_logger = LoggerFactory.getLogger(name)
-    end
-
-    # Dynamically define the methods for each level as identified by the levels constant
-    # This creates a method for each level that looks like this
-    # def <level>(msg=nil, &block)
-    #   log(severity: <level>, msg: msg, &block)
-    # end
-    LEVELS.each do |level|
-      method = level.to_s.downcase
-      define_method(method.to_s) do |msg = nil, &block|
-        log(severity: level, msg: msg, &block)
-      end
-    end
-
-    private
-
-    #
-    # Log a message to the OpenHAB Logger
-    #
-    # @param [Symbol] severity Severity to log message at
-    # @param [Object] msg to log, if no msg supplied and a block is provided,
-    #   the msg is taken from the result of the block
-    #
-    def log(severity:, msg: nil)
-      severity = severity.to_sym
-
-      raise ArgumentError, "Unknown Severity #{severity}" unless LEVELS.include? severity
-
-      # Dynamically check enablement of underlying logger, this expands to "is_<level>_enabled"
-      return unless @sl4fj_logger.send("is_#{severity.to_s.downcase}_enabled")
-
-      # Process block if no message provided
-      msg = yield if msg.nil? && block_given?
-
-      msg = message_to_string(msg: msg)
-
-      # Dynamically invoke underlying logger, this expands to "<level>(message)"
-      @sl4fj_logger.send(severity.to_s.downcase, msg)
-    end
-
-    #
-    # Conver the supplied message object to a String
-    #
-    # @param [object] msg object to convert
-    #
-    # @return [String] Msg object as a string
-    #
-    def message_to_string(msg:)
-      case msg
-      when ::String
-        msg
-      when ::Exception
-        "#{msg.message} (#{msg.class})\n#{msg.backtrace&.join("\n")}"
-      else
-        msg.inspect
-      end
-    end
-  end
-
-  @loggers = {}
-
-  # Return a logger with the configured log prefix plus the calling scripts name
-
-  #
-  # Create a logger for the current class
-  #
-  # @return [Logger] for the current class
-  #
-  def logger
-    Logging.logger(self.class.name)
-  end
-
-  class << self
-    #
-    # Injects a logger into the base class
-    #
-    # @param [String] name of the logger
-    #
-    # @return [Logger] for the supplied name
-    #
-    def logger(name)
-      name ||= self.class.name
-      @loggers[name] ||= Logging.logger_for(name)
-    end
-
-    #
-    # Configure a logger for the supplied class name
-    #
-    # @param [String] classname to configure logger for
-    #
-    # @return [Logger] for the supplied classname
-    #
-    def logger_for(classname)
-      configure_logger_for(classname)
-    end
-
-   private
-
-    #
-    # Configure a logger for the supplied classname
-    #
-    # @param [String] classname to create logger for
-    #
-    # @return [Logger] Logger for the supplied classname
-    #
-    def configure_logger_for(classname)
-      log_prefix = Configuration.log_prefix
-      log_prefix += if classname
-                      ".#{classname}"
-                    else
-                      ".#{log_caller}"
-                    end
-      Logger.new(log_prefix)
-    end
-
-    #
-    # Figure out the log prefix
-    #
-    # @return [String] Prefix for log messages
-    #
-    def log_caller
-      caller_locations.map(&:path)
-                      .grep_v(%r{openhab/core/})
-                      .grep_v(/rubygems/)
-                      .grep_v(%r{lib/ruby})
-                      .first
-                      .yield_self { |caller| File.basename(caller, '.*') }
-    end
- end
-
-  #
-  # Add logger method to the object that includes this module
-  #
-  # @param [Object] base Object to add method to
-  #
-  #
-  def self.included(base)
-    class << base
-      def logger
-        Logging.logger(self.class.name)
-      end
-    end
-  end
-end