openhab-scripting 4.46.2 → 5.0.0

data/lib/openhab/dsl/rules/rule_config.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require 'java'
-require 'forwardable'
-require_relative 'property'
-require_relative 'triggers/triggers'
-require_relative 'guard'
-require_relative 'rule_triggers'
-require 'openhab/core/entity_lookup'
-require 'openhab/dsl/between'
-require 'openhab/dsl/timers'
-
-module OpenHAB
-  module DSL
-    #
-    # Creates and manages OpenHAB Rules
-    #
-    module Rules
-      #
-      # Rule configuration for OpenHAB Rules engine
-      #
-      class RuleConfig
-        include OpenHAB::Log
-        include OpenHAB::Core::EntityLookup
-        prepend OpenHAB::DSL::Rules::Triggers
-        include OpenHAB::DSL::Rules::Guard
-        include OpenHAB::DSL::Rules::Property
-        extend Forwardable
-
-        # Provide backwards compatibility for these fields
-        delegate %i[triggers trigger_conditions attachments] => :@rule_triggers
-
-        # @return [Array] Of trigger guards
-        attr_accessor :guard
-
-        # @return [Object] object that invoked rule method
-        attr_accessor :caller
-
-        # @return [Array] Of trigger definitions as passed in Ruby
-        attr_reader :ruby_triggers
-
-        #
-        # Struct holding a run block
-        #
-        Run = Struct.new(:block)
-
-        #
-        # Struct holding a Triggered block
-        #
-        Trigger = Struct.new(:block)
-
-        #
-        # Struct holding an otherwise block
-        #
-        Otherwise = Struct.new(:block)
-
-        #
-        # Struct holding rule delays
-        #
-        Delay = Struct.new(:duration)
-
-        prop_array :run, :array_name => :run_queue, :wrapper => Run
-        prop_array :triggered, :array_name => :run_queue, :wrapper => Trigger
-        prop_array :delay, :array_name => :run_queue, :wrapper => Delay
-        prop_array :otherwise, :array_name => :run_queue, :wrapper => Otherwise
-
-        prop :uid
-        prop :name
-        prop :description
-        prop :tags
-        prop :enabled
-        prop :between
-
-        #
-        # Create a new RuleConfig
-        #
-        # @param [Object] caller_binding The object initializing this configuration.
-        #   Used to execute within the object's context
-        #
-        def initialize(caller_binding)
-          @rule_triggers = RuleTriggers.new
-          @caller = caller_binding.eval 'self'
-          @ruby_triggers = []
-          enabled(true)
-          on_start(false)
-          tags([])
-        end
-
-        #
-        # Start this rule on system startup
-        #
-        # @param [Boolean] run_on_start Run this rule on start, defaults to True
-        # @param [Object] attach object to be attached to the trigger
-        #
-        # rubocop: disable Style/OptionalBooleanParameter
-        # Disabled cop due to use in a DSL
-        def on_start(run_on_start = true, attach: nil)
-          @on_start = Struct.new(:enabled, :attach).new(run_on_start, attach)
-        end
-        # rubocop: enable Style/OptionalBooleanParameter
-
-        #
-        # Checks if this rule should run on start
-        #
-        # @return [Boolean] True if rule should run on start, false otherwise.
-        #
-        def on_start?
-          @on_start.enabled
-        end
-
-        #
-        # Get the optional start attachment
-        #
-        # @return [Object] optional user provided attachment to the on_start method
-        #
-        def start_attachment
-          @on_start.attach
-        end
-
-        #
-        # Run the supplied block inside the object instance of the object that created the rule config
-        #
-        # @yield [] Block executed in context of the object creating the rule config
-        #
-        #
-        def my(&block)
-          @caller.instance_eval(&block)
-        end
-
-        #
-        # Inspect the config object
-        #
-        # @return [String] details of the config object
-        #
-        def inspect
-          "Name: (#{name}) " \
-            "Triggers: (#{triggers}) " \
-            "Run blocks: (#{run}) " \
-            "on_start: (#{on_start?}) " \
-            "Trigger Conditions: #{trigger_conditions} " \
-            "Trigger UIDs: #{triggers.map(&:id).join(', ')} " \
-            "Attachments: #{attachments}"
-        end
-      end
-    end
-  end
-end

data/lib/openhab/dsl/rules/triggers/generic.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'openhab/log/logger'
-require_relative 'trigger'
-
-module OpenHAB
-  module DSL
-    module Rules
-      #
-      # Module holds rule triggers
-      #
-      module Triggers
-        include OpenHAB::Log
-
-        #
-        # Create a generic trigger given the trigger type uid and a configuration hash
-        #
-        # @param [Type] type Trigger type UID
-        # @param [Object] attach object to be attached to the trigger
-        # @param [Configuration] configuration A hash containing the trigger configuration entries
-        #
-        # @return [Trigger] Trigger object
-        #
-        def trigger(type, attach: nil, **configuration)
-          logger.trace("Creating a generic trigger for type(#{type}) with configuration(#{configuration})")
-          Trigger.new(rule_triggers: @rule_triggers).append_trigger(type: type, config: configuration, attach: attach)
-        end
-      end
-    end
-  end
-end

data/lib/openhab/dsl/rules/triggers/triggers.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'cron/cron'
-require_relative 'cron/cron_handler'
-require_relative 'changed'
-require_relative 'channel'
-require_relative 'command'
-require_relative 'updated'
-require_relative 'generic'
-require_relative 'watch/watch'
-require_relative 'watch/watch_handler'

data/lib/openhab/dsl/rules/triggers/watch/watch.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require 'openhab/log/logger'
-require 'openhab/dsl/rules/triggers/trigger'
-
-module OpenHAB
-  module DSL
-    module Rules
-      #
-      # Module holds rule triggers
-      #
-      module Triggers
-        #
-        # Module for watching directories/files
-        #
-
-        #
-        # Create a trigger to watch a path
-        #
-        # @param [String] path to watch
-        # @param [String] glob
-        # @param [Array, Symbol] for types of changes to watch: +:created+, +:deleted+, +:modified+
-        # @param [Object] attach object to be attached to the trigger
-        #
-        # @return [Trigger] Trigger object
-        #
-        def watch(path, glob: '*', for: %i[created deleted modified], attach: nil)
-          glob, path = Watch.glob_for_path(Pathname.new(path), glob)
-          types = [binding.local_variable_get(:for)].flatten
-          config = { path: path.to_s, types: types.map(&:to_s), glob: glob.to_s }
-
-          logger.state 'Creating a watch trigger', path: path, glob: glob, types: types
-          Watch.new(rule_triggers: @rule_triggers).trigger(config: config, attach: attach)
-        end
-
-        #
-        # Creates watch triggers
-        #
-        class Watch < Trigger
-          # Characters in an fnmatch compatible glob
-          GLOB_CHARS = ['**', '*', '?', '[', ']', '{', '}'].freeze
-          private_constant :GLOB_CHARS
-
-          #
-          # Automatically creates globs for supplied paths if necessary
-          #
-          # @param [Pathname] path to check
-          # @param [String] glob
-          #
-          # @return [Pathname,String] Pathname to watch and glob to match
-          #
-          def self.glob_for_path(path, glob)
-            # Checks if the supplied pathname last element contains a glob char
-            if GLOB_CHARS.any? { |char| path.basename.to_s.include? char }
-              # Splits the supplied pathname into a glob string and parent path
-              [path.basename.to_s, path.parent]
-            elsif path.file? || !path.exist?
-              # glob string matching end of Pathname and parent path
-              ["*/#{path.basename}", path.parent]
-            else
-              [glob, path]
-            end
-          end
-
-          #
-          # Create a watch trigger based on item type
-          #
-          # @param [Config] config Rule configuration
-          # @param [Object] attach object to be attached to the trigger
-          #
-          #
-          def trigger(config:, attach:)
-            append_trigger(type: WatchHandler::WATCH_TRIGGER_MODULE_ID,
-                           config: config,
-                           attach: attach)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/openhab/dsl/states.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-require 'delegate'
-
-module OpenHAB
-  module DSL
-    #
-    # Manages storing and restoring item state
-    #
-    module States
-      module_function
-
-      #
-      # Store states of supplied items
-      #
-      # @param [Array] items to store states of
-      #
-      # @return [StateStorage] item states
-      #
-      def store_states(*items)
-        items = items.flatten.map do |item|
-          item.respond_to?(:__getobj__) ? item.__getobj__ : item
-        end
-        states = OpenHAB::DSL::Support::StateStorage.from_items(*items)
-        if block_given?
-          yield
-          states.restore
-        end
-        states
-      end
-
-      #
-      # Check if all the given items have a state (not UNDEF or NULL)
-      #
-      # @param [Array] items whose state must be non-nil
-      # @param [<Type>] things when true, also ensures that all linked things are online
-      #
-      # @return [Boolean] true if all the items have a state, false otherwise
-      #
-      def state?(*items, things: false)
-        items.flatten.all? { |item| (!things || item.things.all?(&:online?)) && item.state? }
-      end
-    end
-
-    module Support
-      java_import org.openhab.core.model.script.actions.BusEvent
-      #
-      # Delegates state storage to a Hash providing methods to operate with states
-      #
-      class StateStorage < SimpleDelegator
-        #
-        # Create a StateStorage object that stores the states of the given items
-        #
-        # @param [Array<Item>] items A list of items
-        #
-        # @return [StateStorage] A state storage object
-        #
-        def self.from_items(*items)
-          StateStorage.new(BusEvent.storeStates(*items).to_h)
-        end
-
-        #
-        # Restore the stored states of all items
-        #
-        #
-        def restore
-          BusEvent.restoreStates(to_h)
-        end
-
-        #
-        # Restore states for items that have changed
-        #
-        #
-        def restore_changes
-          BusEvent.restoreStates(select { |item, value| item != value })
-        end
-
-        #
-        # Detect if any item have changed states since being stored
-        #
-        # @return [Boolean] True if any items have changed states, false otherwise
-        #
-        def changed?
-          any? { |item, value| item != value }
-        end
-      end
-    end
-  end
-end

data/lib/openhab/dsl/things.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require 'delegate'
-require 'java'
-require 'singleton'
-
-require 'openhab/log/logger'
-require 'openhab/dsl/actions'
-require 'openhab/dsl/lazy_array'
-
-module OpenHAB
-  module DSL
-    #
-    # Support for OpenHAB Things
-    #
-    module Things
-      java_import org.openhab.core.thing.ThingStatus
-      include OpenHAB::Log
-
-      #
-      # Ruby Delegator for Thing
-      #
-      class Thing < SimpleDelegator
-        # Array wrapper class to allow searching a list of channels
-        # by channel id
-        class ChannelsArray < Array
-          # Allows indexing by both integer as an array or channel id acting like a hash.
-          # @param [Integer, String] index Numeric index or string channel id to search for.
-          def [](index)
-            if index.respond_to?(:to_str)
-              key = index.to_str
-              return find { |channel| channel.uid.id == key }
-            end
-
-            super
-          end
-        end
-
-        include OpenHAB::DSL::Actions
-        include OpenHAB::Log
-
-        def initialize(thing)
-          super
-          define_action_methods
-        end
-
-        #
-        # Defines boolean thing status methods
-        #   uninitialized?
-        #   initializing?
-        #   unknown?
-        #   online?
-        #   offline?
-        #   removing?
-        #   removed?
-        #
-        # @return [Boolean] true if the thing status matches the name
-        #
-        ThingStatus.constants.each do |thingstatus|
-          define_method("#{thingstatus.to_s.downcase}?") { status == ThingStatus.value_of(thingstatus) }
-        end
-
-        # Returns the list of channels associated with this Thing
-        # @return [Array] channels
-        def channels
-          ChannelsArray.new(super.to_a)
-        end
-
-        private
-
-        java_import org.openhab.core.automation.annotation.RuleAction
-
-        #
-        # Define methods from actions mapped to this thing
-        #
-        #
-        def define_action_methods
-          actions_for_thing(uid).each do |action|
-            methods = action.java_class.declared_instance_methods
-            methods.select { |method| method.annotation_present?(RuleAction.java_class) }
-                   .each { |method| define_action_method(action: action, method: method.name) }
-          end
-        end
-
-        #
-        # Define a method, delegating to supplied action class
-        #
-        # @param [Object] action object to delegate method to
-        # @param [String] method Name of method to delegate
-        #
-        #
-        def define_action_method(action:, method:)
-          logger.trace("Adding action method '#{method}' to thing '#{uid}'")
-          define_singleton_method(method) do |*args|
-            action.public_send(method, *args)
-          end
-        end
-      end
-
-      #
-      # Wraps all Things in a delegator to underlying set and provides lookup method
-      #
-      class Things
-        include LazyArray
-        include Singleton
-
-        # Gets a specific thing by name in the format binding_id:type_id:thing_id or via the ThingUID
-        # @return Thing specified by name/UID or nil if name/UID does not exist in thing registry
-        def [](uid)
-          uid = generate_thing_uid(uid) unless uid.is_a?(org.openhab.core.thing.ThingUID)
-          thing = $things.get(uid)
-          return unless thing
-
-          logger.trace("Retrieved Thing(#{thing}) from registry for uid: #{uid}")
-          Thing.new(thing)
-        end
-        alias include? []
-        alias key? []
-
-        # explicit conversion to array
-        def to_a
-          $things.getAll.map { |thing| Thing.new(thing) }
-        end
-
-        private
-
-        # Returns a ThingUID given a string like object
-        #
-        # @return ThingUID generated by given name
-        def generate_thing_uid(uid)
-          org.openhab.core.thing.ThingUID.new(*uid.split(':'))
-        end
-      end
-
-      module_function
-
-      #
-      # Get all things known to OpenHAB
-      #
-      # @return [Things] all Thing objects known to OpenHAB
-      #
-      def things
-        Things.instance
-      end
-    end
-  end
-end

data/lib/openhab/dsl/time/month_day.rb

@@ -1,180 +0,0 @@
-# frozen_string_literal: true
-
-require 'java'
-
-module OpenHAB
-  module DSL
-    # Support for time related functions
-    module Between
-      # Manages Month Day Ranges
-      module MonthDayRange
-        include OpenHAB::Log
-
-        # Creates a range that can be compared against MonthDay objects, strings
-        # or anything responding to 'to_date' to see if they are within the range
-        # @return Range object representing a MonthDay Range
-        def self.range(range)
-          raise ArgumentError, 'Supplied object must be a range' unless range.is_a? Range
-
-          start = MonthDay.parse(range.begin)
-          ending = MonthDay.parse(range.end)
-
-          start_range = DayOfYear.new(month_day: start, range: start..ending)
-          ending_range = DayOfYear.new(month_day: ending, range: start..ending)
-          logger.trace "Month Day Range Start(#{start}) - End (#{ending}) - Created from (#{range})"
-
-          range.exclude_end? ? (start_range...ending_range) : (start_range..ending_range)
-        end
-
-        # Checks if supplied range can be converted to a month day range
-        # @param [Range] range to check begin and end values of
-        # @return [Boolean] Returns true if supplied range can be converted to a month day range
-        def self.range?(range)
-          return false unless range.is_a? Range
-
-          MonthDay.day_of_month?(range.begin) && MonthDay.day_of_month?(range.end)
-        end
-
-        # Converts a MonthDay to a day of year
-        # which is represented as a number from 1 to 732 to support comparisions when the range overlaps a year boundary
-        class DayOfYear
-          include Comparable
-          include OpenHAB::Log
-          java_import java.time.LocalDate
-
-          attr_accessor :month_day
-
-          # Number of days in a leap year
-          DAYS_IN_YEAR = 366
-
-          # Create a new MonthDayRange element
-          # @param [MonthDay] month_day MonthDay element
-          # @param [Range] range Underlying MonthDay range
-          #
-          def initialize(month_day:, range:)
-            @month_day = month_day
-            @range = range
-          end
-
-          # Returns the MonthDay advanced by 1 day
-          # Required by Range class
-          def succ
-            next_day_of_month = @month_day.day_of_month + 1
-            next_month = @month_day.month_value
-
-            if next_day_of_month > @month_day.month.max_length
-              next_day_of_month = 1
-              next_month = @month_day.month.plus(1).value
-            end
-
-            DayOfYear.new(month_day: MonthDay.of(next_month, next_day_of_month), range: @range)
-          end
-
-          #
-          # Offset by 1 year if the range begin is greater than the range end
-          # and if the month day is less than the begining of the range
-          # @return [Number] 366 if the month_day should be offset by a year
-          def offset
-            @range.begin > @range.end && month_day < @range.begin ? DAYS_IN_YEAR : 0
-          end
-
-          #
-          # Calculate the day within the range for the underlying month day
-          # @return [Number] Representation of the MonthDay as a number from 1 to 732
-          def day_in_range
-            @day_in_range ||= month_day.max_day_of_year + offset
-          end
-
-          # Compare MonthDayRangeElement to other objects as required by Range class
-          def <=>(other) # rubocop:disable Metrics/AbcSize
-            case other
-            when DayOfYear then day_in_range.<=>(other.day_in_range)
-            when MonthDay then self.<=>(DayOfYear.new(month_day: other, range: @range))
-            when LocalDate then self.<=>(MonthDay.of(other.month_value, other.day_of_month))
-            when Date then self.<=>(MonthDay.of(other.month, other.day))
-            else
-              return self.<=>(other.to_local_date) if other.respond_to?(:to_local_date)
-              return self.<=>(other.to_date) if other.respond_to?(:to_date)
-
-              raise "Unable to convert #{other.class} to compare to MonthDay"
-            end
-          end
-        end
-      end
-
-      java_import java.time.MonthDay
-      # Extend MonthDay java object with some helper methods
-      class MonthDay
-        include OpenHAB::Log
-        java_import java.time.format.DateTimeFormatter
-        java_import java.time.Month
-
-        #
-        # Constructor
-        #
-        # @param [Integer] m month
-        # @param [Integer] d day of month
-        #
-        # @return [Object] MonthDay object
-        #
-        def self.new(m:, d:) # rubocop:disable Naming/MethodParameterName
-          MonthDay.of(m, d)
-        end
-
-        # Calcalute the maximum number of days in a year before a supplied month
-        # @return [Number] maximum nummber of days in a year before this month
-        def max_days_before(month)
-          java.time.Month.values.select { |i| i < month }.sum(&:max_length)
-        end
-
-        # Parse MonthDay string as defined with by Monthday class without leading double dash "--"
-        def self.parse(string)
-          logger.trace("#{self.class}.parse #{string} (#{string.class})")
-          java_send :parse, [java.lang.CharSequence, java.time.format.DateTimeFormatter],
-                    string.to_s,
-                    DateTimeFormatter.ofPattern('[--]M-d')
-        end
-
-        # Can the supplied object be parsed into a MonthDay
-        def self.day_of_month?(obj)
-          /^-*[01][0-9]-[0-3]\d$/.match? obj.to_s
-        end
-
-        # Get the maximum (supports leap years) day of the year this month day could be
-        def max_day_of_year
-          day_of_month + max_days_before(month)
-        end
-
-        # Remove -- from MonthDay string representation
-        def to_s
-          to_string.delete_prefix('--')
-        end
-
-        # Checks if MonthDay is between the dates of the supplied range
-        # @param [Range] range to check against MonthDay
-        # @return [true,false] true if the MonthDay falls within supplied range, false otherwise
-        def between?(range)
-          MonthDayRange.range(range).cover? self
-        end
-
-        # remove the inherited #== method to use our <=> below
-        remove_method :==
-
-        # Extends MonthDay comparison to support Strings
-        # Necessary to support mixed ranges of Strings and MonthDay types
-        # @return [Number, nil] -1,0,1 if other MonthDay is less than, equal to, or greater than this MonthDay
-        def <=>(other)
-          case other
-          when String
-            self.<=>(MonthDay.parse(other))
-          when OpenHAB::DSL::Between::MonthDayRange::DayOfYear
-            # Compare with DayOfYear and invert result
-            -(other <=> self)
-          else
-            super
-          end
-        end
-      end
-    end
-  end
-end