openhab-scripting 2.9.1

data/lib/openhab/core/dsl/monkey_patch/ruby/ruby.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# Monkey patch ruby
+require 'openhab/core/dsl/monkey_patch/ruby/range'
+require 'openhab/core/dsl/monkey_patch/ruby/number'

data/lib/openhab/core/dsl/monkey_patch/types/decimal_type.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'java'
+
+#
+# MonkeyPatching Decimal Type
+#
+# rubocop:disable Style/ClassAndModuleChildren
+class Java::OrgOpenhabCoreLibraryTypes::DecimalType
+  # rubocop:enable Style/ClassAndModuleChildren
+
+  #
+  # Compare self to other using Java BigDecimal compare method
+  #
+  # @param [Object] other object to compare to
+  #
+  # @return [Boolean] True if have the same BigDecimal representation, false otherwise
+  #
+  def ==(other)
+    return equals(other) unless other.is_a? Integer
+
+    to_big_decimal.compare_to(Java::JavaMath::BigDecimal.new(other)).zero?
+  end
+end

data/lib/openhab/core/dsl/monkey_patch/types/on_off_type.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'java'
+
+#
+# Monkey patching OnOffType
+#
+# rubocop:disable Style/ClassAndModuleChildren
+class Java::OrgOpenhabCoreLibraryTypes::OnOffType
+  # rubocop:enable Style/ClassAndModuleChildren
+
+  #
+  # Invert the type
+  #
+  # @return [Java::OrgOpenhabCoreLibraryTypes::OnOffType] OFF if ON, ON if OFF
+  #
+  def !
+    return OFF if self == ON
+    return ON if self == OFF
+  end
+
+  # Check if the supplied object is case equals to self
+  #
+  # @param [Object] other object to compare
+  #
+  # @return [Boolean] True if the other object responds to on?/off? and is in the same state as this object,
+  #  nil if object cannot be compared
+  #
+  def ===(other)
+    # A case statement here causes and infinite loop
+    # rubocop:disable Style/CaseLikeIf
+    if self == ON
+      other.on? if other.respond_to? :on?
+    elsif self == OFF
+      other.off? if other.respond_to?('off?')
+    else
+      false
+    end
+    # rubocop:enable Style/CaseLikeIf
+  end
+end

data/lib/openhab/core/dsl/monkey_patch/types/open_closed_type.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'java'
+
+#
+# Monkey patch for DSL use
+#
+# rubocop:disable Style/ClassAndModuleChildren
+class Java::OrgOpenhabCoreLibraryTypes::OpenClosedType
+  # rubocop:enable Style/ClassAndModuleChildren
+  java_import org.openhab.core.library.items.ContactItem
+
+  #
+  # Check if the supplied object is case equals to self
+  #
+  # @param [Object] other object to compare
+  #
+  # @return [Boolean] True if the other object is a ContactItem and has the same state
+  #
+  def ===(other)
+    super unless other.is_a? ContactItem
+
+    self == other.state
+  end
+end

data/lib/openhab/core/dsl/monkey_patch/types/percent_type.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'java'
+
+#
+# MonkeyPatching PercentType
+#
+# rubocop:disable Style/ClassAndModuleChildren
+class Java::OrgOpenhabCoreLibraryTypes::PercentType
+  # rubocop:enable Style/ClassAndModuleChildren
+
+  #
+  # Need to override and point to super because default JRuby implementation doesn't point to == of parent class
+  #
+  # @param [Object] other object to check equality for
+  # @return [Boolean] True if other equals self, false otherwise
+  #
+  # rubocop:disable Lint/UselessMethodDefinition
+  def ==(other)
+    super
+  end
+  # rubocop:enable Lint/UselessMethodDefinition
+end

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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Monkey patch types
+require 'core/dsl/monkey_patch/types/open_closed_type'
+require 'core/dsl/monkey_patch/types/on_off_type'
+require 'core/dsl/monkey_patch/types/decimal_type'
+require 'core/dsl/monkey_patch/types/percent_type'

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'core/log'
+
+#
+# Provides methods to support DSL properties
+#
+module DSLProperty
+  include Logging
+
+  #
+  # Extend the calling object with the property methods
+  #
+  # @param [Object] base object to extend
+  #
+  #
+  def self.included(base)
+    base.extend PropertyMethods
+  end
+
+  #
+  # Methods that support creating properties in the DSL
+  #
+  module PropertyMethods
+    #
+    # Dynamically creates a property that acts and an accessor with no arguments
+    # and a setter with any number of arguments or a block.
+    #
+    # @param [String] name of the property
+    #
+    #
+    def prop(name)
+      define_method(name) do |*args, &block|
+        if args.length.zero? && block.nil? == true
+          instance_variable_get("@#{name}")
+        else
+          logger.trace("Property '#{name}' called with args(#{args}) and block(#{block})")
+          if args.length == 1
+            instance_variable_set("@#{name}", args.first)
+          elsif args.length > 1
+            instance_variable_set("@#{name}", args)
+          elsif block
+            instance_variable_set("@#{name}", block)
+          end
+        end
+      end
+    end
+
+    #
+    # Dynamically creates a property array acts and an accessor with no arguments
+    # and a pushes any number of arguments or a block onto they property array
+    # You can provide a block to this method which can be used to check if the provided value is acceptable.
+    #
+    # @param [String] name of the property
+    # @param [String] array_name name of the array to use, defaults to name of property
+    # @param [Class] wrapper object to put around elements added to the array
+    #
+    def prop_array(name, array_name: nil, wrapper: nil)
+      define_method(name) do |*args, &block|
+        array_name ||= name
+        if args.length.zero? && block.nil? == true
+          instance_variable_get("@#{array_name}")
+        else
+          logger.trace("Property '#{name}' called with args(#{args}) and block(#{block})")
+          if args.length == 1
+            insert = args.first
+          elsif args.length > 1
+            insert = args
+          elsif block
+            insert = block
+          end
+          yield insert if block_given?
+          insert = wrapper.new(insert) if wrapper
+          instance_variable_set("@#{array_name}", (instance_variable_get("@#{array_name}") || []) << insert)
+        end
+      end
+
+      if array_name
+        define_method(array_name) do
+          instance_variable_get("@#{array_name}")
+        end
+      end
+    end
+  end
+end

data/lib/openhab/core/dsl/rule/channel.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'core/log'
+require 'openhab/core/dsl/rule/triggers'
+
+module OpenHAB
+  module Core
+    module DSL
+      module Rule
+        #
+        # Channel triggers
+        #
+        module Channel
+          include Logging
+
+          #
+          # Creates a channel trigger
+          #
+          # @param [Array] channels array to create triggers for on form of 'binding_id:type_id:thing_id#channel_id' or 'channel_id' if thing is provided
+          # @param [thing] thing to create trigger for if not specified with the channel
+          # @param [String] triggered specific triggering condition to match for trigger
+          #
+          #
+          def channel(*channels, thing: nil, triggered: nil)
+            channels.flatten.each do |channel|
+              channel = [thing, channel].join(':') if thing
+              logger.trace("Creating channel trigger for channel(#{channel}), thing(#{thing}), trigger(#{triggered})")
+              [triggered].flatten.each do |trigger|
+                config = { 'channelUID' => channel }
+                config['event'] = trigger.to_s unless trigger.nil?
+                config['channelUID'] = channel
+                logger.trace("Creating Change Trigger for #{config}")
+                @triggers << Trigger.trigger(type: Trigger::CHANNEL_EVENT, config: config)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openhab/core/dsl/rule/cron.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'java'
+require 'core/duration'
+require 'core/dsl/time_of_day'
+require 'core/cron'
+
+module OpenHAB
+  module Core
+    module DSL
+      module Rule
+        #
+        # Cron type rules
+        #
+        module Cron
+          java_import org.openhab.core.automation.util.TriggerBuilder
+          java_import org.openhab.core.config.core.Configuration
+
+          include OpenHAB::Core::DSL::Rule
+          extend OpenHAB::Core::Cron
+
+          # @return [Map] Map of days of the week from symbols to to OpenHAB cron strings
+          DAY_OF_WEEK_MAP = {
+            monday: 'MON',
+            tuesday: 'TUE',
+            wednesday: 'WED',
+            thursday: 'THU',
+            friday: 'FRI',
+            saturday: 'SAT',
+            sunday: 'SUN'
+          }.freeze
+
+          private_constant :DAY_OF_WEEK_MAP
+
+          # @return [MAP] Converts the DAY_OF_WEEK_MAP to map used by Cron Expression
+          DAY_OF_WEEK_EXPRESSION_MAP = DAY_OF_WEEK_MAP.transform_values { |v| cron_expression_map.merge(dow: v) }
+
+          private_constant :DAY_OF_WEEK_EXPRESSION_MAP
+
+          # @return [Map] Create a set of cron expressions based on different time intervals
+          EXPRESSION_MAP = {
+            second: cron_expression_map,
+            minute: cron_expression_map.merge(second: '0'),
+            hour: cron_expression_map.merge(second: '0', minute: '0'),
+            day: cron_expression_map.merge(second: '0', minute: '0', hour: '0'),
+            week: cron_expression_map.merge(second: '0', minute: '0', hour: '0', dow: 'MON'),
+            month: cron_expression_map.merge(second: '0', minute: '0', hour: '0', dom: '1'),
+            year: cron_expression_map.merge(second: '0', minute: '0', hour: '0', dom: '1', month: '1')
+          }.merge(DAY_OF_WEEK_EXPRESSION_MAP)
+                           .freeze
+
+          private_constant :EXPRESSION_MAP
+
+          #
+          # Create a rule that executes at the specified interval
+          #
+          # @param [Object] value Symbol or Duration to execute this rule
+          # @param [Object] at TimeOfDay or String representing TimeOfDay in which to execute rule
+          #
+          #
+          def every(value, at: nil)
+            case value
+            when Symbol
+              expression_map = EXPRESSION_MAP[value]
+              expression_map = at_condition(expression_map, at) if at
+              cron(map_to_cron(expression_map))
+            when Duration
+              cron(map_to_cron(value.cron_map))
+            else
+              raise ArgumentExpression, 'Unknown interval' unless expression_map
+            end
+          end
+
+          #
+          # Create a OpenHAB Cron trigger
+          #
+          # @param [String] expression OpenHAB style cron expression
+          #
+          def cron(expression)
+            @triggers << Trigger.trigger(type: Trigger::CRON, config: { 'cronExpression' => expression })
+          end
+
+          private
+
+          #
+          # Map cron expression to to cron string
+          #
+          # @param [Map] map of cron expression
+          #
+          # @return [String] OpenHAB cron string
+          #
+          def map_to_cron(map)
+            %i[second minute hour dom month dow].map { |field| map.fetch(field) }.join(' ')
+          end
+
+          #
+          # If an at time is provided, parse that and merge the new fields into the expression.
+          #
+          # @param [<Type>] expression_map <description>
+          # @param [<Type>] at_time <description>
+          #
+          # @return [<Type>] <description>
+          #
+          def at_condition(expression_map, at_time)
+            if at_time
+              tod = (at_time.is_a? TimeOfDay) ? at_time : TimeOfDay.parse(at_time)
+              expression_map = expression_map.merge(hour: tod.hour, minute: tod.minute, second: tod.second)
+            end
+            expression_map
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openhab/core/dsl/rule/guard.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'core/dsl/property'
+require 'core/log'
+
+module OpenHAB
+  module Core
+    module DSL
+      module Rule
+        #
+        # Guards for rules
+        #
+        module Guard
+          include DSLProperty
+
+          prop_array(:only_if) do |item|
+            unless item.is_a?(Proc) || item.respond_to?(:truthy?)
+              raise ArgumentError, "Object passed to only_if must respond_to 'truthy?'"
+            end
+          end
+
+          prop_array(:not_if) do |item|
+            unless item.is_a?(Proc) || item.respond_to?(:truthy?)
+              raise ArgumentError, "Object passed to not_if must respond_to 'truthy?'"
+            end
+          end
+
+          #
+          # Guard that can prevent execute of a rule if not satisfied
+          #
+          class Guard
+            include Logging
+
+            #
+            # Create a new Guard
+            #
+            # @param [Object] only_if Item or Proc to use as guard
+            # @param [Object] not_if Item or Proc to use as guard
+            #
+            def initialize(only_if: nil, not_if: nil)
+              @only_if = only_if
+              @not_if = not_if
+            end
+
+            #
+            # Convert the guard into a string
+            #
+            # @return [String] describing the only_of and not_if guards
+            #
+            def to_s
+              "only_if: #{@only_if}, not_if: #{@not_if}"
+            end
+
+            #
+            # Checks if a guard should run
+            #
+            # @param [OpenHAB Trigger Event] event OpenHAB Trigger Event
+            #
+            # @return [Boolean] True if guard is satisfied, false otherwise
+            #
+            def should_run?(event)
+              logger.trace("Checking guards #{self}")
+              check(@only_if, check_type: :only_if, event: event) && check(@not_if, check_type: :not_if, event: event)
+            end
+
+            private
+
+            #
+            # Check if guard is satisfied
+            #
+            # @param [Array] conditions to check
+            # @param [Symbol] check_type type of check to perform (:only_if or :not_if)
+            # @param [Event] event OpenHAB event to see if it satisfies the guard
+            #
+            # @return [Boolean] True if guard is satisfied, false otherwise
+            #
+            def check(conditions, check_type:, event:)
+              return true if conditions.nil? || conditions.empty?
+
+              procs, items = conditions.flatten.partition { |condition| condition.is_a? Proc }
+              logger.trace("Procs: #{procs} Items: #{items}")
+
+              items.each { |item| logger.trace("#{item} truthy? #{item.truthy?}") }
+
+              case check_type
+              when :only_if
+                items.all?(&:truthy?) && procs.all? { |proc| proc.call(event) }
+              when :not_if
+                items.none?(&:truthy?) && procs.none? { |proc| proc.call(event) }
+              else
+                raise ArgumentError, "Unexpected check type: #{check_type}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end