openhab-jrubyscripting 5.0.0.rc1

data/lib/openhab/core_ext/ruby/date.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+# Extensions to Date
+class Date
+  #
+  # Extends {#+} to allow adding a {java.time.temporal.TemporalAmount TemporalAmount}
+  #
+  # @param [java.time.temporal.TemporalAmount] other
+  # @return [LocalDate] If other is a {java.time.temporal.TemporalAmount TemporalAmount}
+  #
+  def plus_with_temporal(other)
+    return to_local_date + other if other.is_a?(java.time.temporal.TemporalAmount)
+
+    plus_without_temporal(other)
+  end
+  alias_method :plus_without_temporal, :+
+  alias_method :+, :plus_with_temporal
+
+  #
+  # Extends {#-} to allow subtracting a {java.time.temporal.TemporalAmount TemporalAmount}
+  #
+  # @param [java.time.temporal.TemporalAmount] other
+  # @return [LocalDate] If other is a {java.time.temporal.TemporalAmount TemporalAmount}
+  #
+  def minus_with_temporal(other)
+    case other
+    when java.time.temporal.TemporalAmount, java.time.LocalDate
+      to_local_date - other
+    else
+      minus_without_temporal(other)
+    end
+  end
+  alias_method :minus_without_temporal, :-
+  alias_method :-, :minus_with_temporal
+
+  # @return [LocalDate]
+  def to_local_date(_context = nil)
+    java.time.LocalDate.of(year, month, day)
+  end
+
+  # @return [Month]
+  def to_month
+    java.time.Month.of(month)
+  end
+
+  # @return [MonthDay]
+  def to_month_day
+    java.time.MonthDay.of(month, day)
+  end
+
+  # @param [ZonedDateTime, nil] context
+  #   A {ZonedDateTime} used to fill in missing fields during conversion.
+  #   {OpenHAB::CoreExt::Java::ZonedDateTime.now ZonedDateTime.now} is assumed
+  #   if not given.
+  # @return [ZonedDateTime]
+  def to_zoned_date_time(context = nil)
+    to_local_date.to_zoned_date_time(context)
+  end
+
+  # @return [Integer, nil]
+  def compare_with_coercion(other)
+    return compare_without_coercion(other) if other.is_a?(self.class)
+
+    return self <=> other.to_date(self) if other.is_a?(java.time.MonthDay)
+
+    if other.respond_to?(:coerce) && (lhs, rhs = coerce(self))
+      return lhs <=> rhs
+    end
+
+    compare_without_coercion(other)
+  end
+  alias_method :compare_without_coercion, :<=>
+  alias_method :<=>, :compare_with_coercion
+
+  #
+  # Convert `other` to Date, if possible.
+  #
+  # @param [#to_date] other
+  # @return [Array, nil]
+  #
+  def coerce(other)
+    return nil unless other.respond_to?(:to_date)
+    return [other.to_date(self), self] if other.method(:to_date).arity == 1
+
+    [other.to_date, self]
+  end
+
+  alias_method :inspect, :to_s
+end

data/lib/openhab/core_ext/ruby/numeric.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+# Extensions to Integer
+class Integer
+  class << self
+    #
+    # @!macro def_duration_method
+    #   @!method $1
+    #
+    #   Create {Duration} of `self` $1
+    #
+    #   @return [Duration]
+    #
+    # @!visibility private
+    def def_duration_method(unit)
+      class_eval <<~RUBY, __FILE__, __LINE__ + 1
+        def #{unit}                            # def seconds
+          java.time.Duration.of_#{unit}(self)  #   java.time.Duration.of_seconds(self)
+        end                                    # end
+      RUBY
+    end
+
+    #
+    # @!macro def_period_method
+    #   @!method $1
+    #
+    #   Create {Period} of `self` $1
+    #
+    #   @return [Period]
+    #
+    # @!visibility private
+    def def_period_method(unit)
+      class_eval <<~RUBY, __FILE__, __LINE__ + 1
+        def #{unit}                          # def days
+          java.time.Period.of_#{unit}(self)  #   java.time.Period.of_days(self)
+        end                                  # end
+      RUBY
+    end
+  end
+
+  #
+  # Create {Duration} of `self` milliseconds
+  #
+  # @return [Duration]
+  #
+  def milliseconds
+    Duration.of_millis(self)
+  end
+  alias_method :millisecond, :milliseconds
+  alias_method :ms, :milliseconds
+  def_duration_method(:seconds)
+  alias_method :second, :seconds
+  def_duration_method(:minutes)
+  alias_method :minute, :minutes
+  def_duration_method(:hours)
+  alias_method :hour, :hours
+  def_period_method(:days)
+  alias_method :day, :days
+  def_period_method(:months)
+  alias_method :month, :months
+  def_period_method(:years)
+  alias_method :year, :years
+end
+
+# Extensions to Float
+class Float
+  #
+  # Create {Duration} of `self` milliseconds
+  #
+  # @return [Duration]
+  #
+  def milliseconds
+    java.time.Duration.of_nanos((self * 1_000_000).to_i)
+  end
+  alias_method :millisecond, :milliseconds
+  alias_method :ms, :milliseconds
+
+  #
+  # Create {Duration} of `self` seconds
+  #
+  # @return [Duration]
+  #
+  def seconds
+    (self * 1000).milliseconds
+  end
+  alias_method :second, :seconds
+
+  #
+  # Create {Duration} of `self` minutes
+  #
+  # @return [Duration]
+  #
+  def minutes
+    (self * 60).seconds
+  end
+  alias_method :minute, :minutes
+
+  #
+  # Create {Duration} of `self` hours
+  #
+  # @return [Duration]
+  #
+  def hours
+    (self * 60).minutes
+  end
+  alias_method :hour, :hours
+
+  #
+  # Create {Duration} of `self` days
+  #
+  # @return [Duration]
+  #
+  def days
+    (self * 24).hours
+  end
+  alias_method :day, :days
+
+  #
+  # Create {Duration} of `self` months
+  #
+  # @return [Duration]
+  #
+  def months
+    (self * java.time.temporal.ChronoUnit::MONTHS.duration.to_i).seconds
+  end
+  alias_method :month, :months
+
+  #
+  # Create {Duration} of `self` years
+  #
+  # @return [Duration]
+  #
+  def years
+    (self * java.time.temporal.ChronoUnit::YEARS.duration.to_i).seconds
+  end
+  alias_method :year, :years
+end
+
+module OpenHAB
+  module CoreExt
+    module Ruby
+      #
+      # Extend Numeric to create quantity object
+      #
+      module QuantityTypeConversion
+        #
+        # Convert Numeric to a QuantityType
+        #
+        # @param [String, javax.measure.Unit] unit
+        #
+        # @return [QuantityType] `self` as a {QuantityType} of the supplied Unit
+        #
+        def |(unit) # rubocop:disable Naming/BinaryOperatorParameterName
+          unit = org.openhab.core.types.util.UnitUtils.parse_unit(unit.to_str) if unit.respond_to?(:to_str)
+
+          return super unless unit.is_a?(javax.measure.Unit)
+
+          Core::Types::QuantityType.new(to_d.to_java, unit)
+        end
+      end
+
+      # Extensions to Numeric
+      module Numeric
+        include QuantityTypeConversion
+        # non-Integer/Float (i.e. BigDecimal) can still be converted to Duration, via converting to float first
+        extend Forwardable
+        def_delegators :to_f,
+                       :milliseconds,
+                       :millisecond,
+                       :ms,
+                       :seconds,
+                       :second,
+                       :minutes,
+                       :minute,
+                       :hours,
+                       :hour,
+                       :day,
+                       :days,
+                       :month,
+                       :months,
+                       :year,
+                       :years
+      end
+
+      # Integer already has #|, so we have to prepend it here
+      ::Integer.prepend(QuantityTypeConversion)
+      ::Numeric.include(Numeric)
+    end
+  end
+end

data/lib/openhab/core_ext/ruby/range.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module CoreExt
+    module Ruby
+      # Extensions to Range
+      module Range
+        def cover?(object)
+          # inverted circular range
+          if circular?
+            return object >= self.begin || object < self.end if exclude_end?
+
+            return object >= self.begin || object <= self.end
+          end
+          super
+        end
+
+        # Delegates to {#cover?} if {#circular?}
+        # @!visibility private
+        def ===(object)
+          return cover?(object) if circular?
+
+          super
+        end
+
+        # normal Range#each will not yield at all if begin > end
+        def each
+          return super unless circular?
+          return to_enum(:each) unless block_given?
+
+          val = self.begin
+          loop do
+            is_end = val == self.end
+            break if is_end && exclude_end?
+
+            yield val
+            break if is_end
+
+            val = val.succ
+          end
+        end
+
+        #
+        # Checks if this range is circular
+        #
+        # A circular range is one whose data type will repeat if keep you keep
+        # calling #succ on it, and whose beginning is after its end.
+        #
+        # Used by {#cover?} to check if the value is between `end` and `begin`,
+        # instead of `begin` and `end`.
+        #
+        # @return [true, false]
+        #
+        def circular?
+          return false if self.begin.nil? || self.end.nil?
+          return false if self.begin <= self.end
+
+          case self.begin || self.end
+          when java.time.LocalTime, java.time.MonthDay, java.time.Month
+            true
+          else
+            false
+          end
+        end
+
+        ::Range.prepend(self)
+      end
+    end
+  end
+end

data/lib/openhab/core_ext/ruby/time.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module OpenHAB
+  module CoreExt
+    module Ruby
+      # Extensions to Time and DateTime
+      module TimeExtensions
+        extend Forwardable
+
+        # @!visibility private
+        def self.included(base)
+          base.send :alias_method, :plus_without_temporal, :+
+          base.send :alias_method, :+, :plus_with_temporal
+          base.send :alias_method, :minus_without_temporal, :-
+          base.send :alias_method, :-, :minus_with_temporal
+        end
+
+        #
+        # @!method +(other)
+        #
+        # Extends {#+} to allow adding a {java.time.temporal.TemporalAmount TemporalAmount}
+        #
+        # @param [java.time.temporal.TemporalAmount] other
+        # @return [ZonedDateTime] If other is a {java.time.temporal.TemporalAmount TemporalAmount}
+        # @return [Time] If other is a Numeric
+        #
+        def plus_with_temporal(other)
+          return to_zoned_date_time + other if other.is_a?(java.time.temporal.TemporalAmount)
+
+          plus_without_temporal(other)
+        end
+
+        #
+        # @!method -(other)
+        #
+        # Extends {#-} to allow subtracting a {java.time.temporal.TemporalAmount TemporalAmount}
+        #
+        # @param [java.time.temporal.TemporalAmount] other
+        # @return [ZonedDateTime] If other is a {java.time.temporal.TemporalAmount TemporalAmount}
+        # @return [Time] If other is a Numeric
+        #
+        def minus_with_temporal(other)
+          return to_zoned_date_time - other if other.is_a?(java.time.temporal.TemporalAmount)
+
+          minus_without_temporal(other)
+        end
+
+        # @return [LocalDate]
+        def to_local_date(_context = nil)
+          java.time.LocalDate.of(year, month, day)
+        end
+
+        # @!method to_local_time
+        #   @return [LocalTime]
+        def_delegator :to_zoned_date_time, :to_local_time
+
+        # @return [Month]
+        def to_month
+          java.time.Month.of(month)
+        end
+
+        # @return [MonthDay]
+        def to_month_day
+          java.time.MonthDay.of(month, day)
+        end
+
+        # @param [ZonedDateTime, nil] context
+        #   A {ZonedDateTime} used to fill in missing fields
+        #   during conversion. Not used in this class.
+        # @return [ZonedDateTime]
+        def to_zoned_date_time(context = nil) # rubocop:disable Lint/UnusedMethodArgument
+          to_java(ZonedDateTime)
+        end
+
+        #
+        # Converts to a {ZonedDateTime} if `other`
+        # is also convertible to a ZonedDateTime.
+        #
+        # @param [#to_zoned_date_time] other
+        # @return [Array, nil]
+        #
+        def coerce(other)
+          [other.to_zoned_date_time(to_zoned_date_time), self] if other.respond_to?(:to_zoned_date_time)
+        end
+      end
+    end
+  end
+end
+
+#
+# Extensions to Ruby Time
+#
+class Time
+  include(OpenHAB::CoreExt::Ruby::TimeExtensions)
+end
+
+#
+# Extensions to Ruby DateTime
+#
+class DateTime
+  include(OpenHAB::CoreExt::Ruby::TimeExtensions)
+end

data/lib/openhab/core_ext.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+Dir[File.expand_path("core_ext/**/*.rb", __dir__)].sort.each do |f|
+  require f
+end
+
+module OpenHAB
+  # Extensions to core classes
+  module CoreExt
+    # Extensions to core Java classes
+    module Java
+    end
+
+    # Extensions to core Ruby classes
+    module Ruby
+    end
+  end
+end

data/lib/openhab/dsl/events/watch_event.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    module Events
+      #
+      # Event object passed by a {Rules::Builder#watch} trigger.
+      #
+      # @!attribute [r] path
+      #   @return [Pathname] The path that had an event
+      # @!attribute [r] type
+      #   @return [:created, :modified, :deleted] Type of change
+      # @!attribute [r] attachment
+      #   @return [Object] The trigger's attachment
+      WatchEvent = Struct.new(:type, :path, :attachment)
+    end
+  end
+end

data/lib/openhab/dsl/events.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    # Contains event classes for events defined by the DSL.
+    module Events
+    end
+  end
+end

data/lib/openhab/dsl/gems.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "bundler/inline"