openhab-jrubyscripting 5.0.0.rc1

data/lib/openhab/core/items/group_item.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "openhab/core/lazy_array"
+
+require_relative "generic_item"
+
+module OpenHAB
+  module Core
+    module Items
+      java_import org.openhab.core.items.GroupItem
+
+      #
+      # A group behaves like a regular item, but also has {#members} which are
+      # nested items that can be enumerated.
+      #
+      # If the group has a particular type, the methods from that type are
+      # directly available.
+      #
+      #
+      # The examples all assume the following items exist.
+      # ```xtend
+      # Group House
+      # // Location perspective
+      # Group GroundFloor  (House)
+      # Group Livingroom   (GroundFloor)
+      # // Functional perspective
+      # Group Sensors      (House)
+      # Group Temperatures (Sensors)
+      #
+      # Number Livingroom_Temperature "Living Room temperature" (Livingroom, Temperatures)
+      # Number Bedroom_Temp "Bedroom temperature" (GroundFloor, Temperatures)
+      # Number Den_Temp "Den temperature" (GroundFloor, Temperatures)
+      # ```
+      #
+      # @!attribute [r] base_item
+      #   @return [GenericItem, nil] A typed item if the group has a particular type.
+      #
+      # @example Operate on items in a group using enumerable methods
+      #   logger.info("Total Temperatures: #{Temperatures.members.count}")
+      #   # Total Temperatures: 3
+      #   logger.info("Temperatures: #{House.members.map(&:name).sort.join(', ')}")
+      #   # Temperatures: GroundFloor, Sensors
+      #
+      # @example Access to the methods and attributes like any item
+      #   logger.info("Group: #{Temperatures.name}" # Group: Temperatures'
+      #
+      # @example Operates on items in nested groups using enumerable methods
+      #   logger.info("House Count: #{House.all_members.count}")
+      #   # House Count: 7
+      #   logger.info("Items: #{House.all_members.grep_v(GroupItem).map(&:label).sort.join(', ')}")
+      #   # Items: Bedroom temperature, Den temperature, Living Room temperature
+      #
+      # @example Iterate through the direct members of the group
+      #   Temperatures.members.each do |item|
+      #     logger.info("#{item.label} is: #{item.state}")
+      #   end
+      #   # Living Room temperature is 22
+      #   # Bedroom temperature is 21
+      #   # Den temperature is 19
+      #
+      # @example
+      #   rule 'Turn off any switch that changes' do
+      #     changed Switches.members
+      #     triggered(&:off)
+      #   end
+      #
+      # @example Built in {Enumerable} functions can be applied to groups.
+      #   logger.info("Max is #{Temperatures.members.map(&:state).max}")
+      #   logger.info("Min is #{Temperatures.members.map(&:state).min}")
+      #
+      class GroupItem < GenericItem
+        #
+        # Class for indicating to triggers that a group trigger should be used
+        #
+        class Members
+          include LazyArray
+
+          # @return [GroupItem]
+          attr_reader :group
+
+          # @!visibility private
+          def initialize(group_item)
+            @group = group_item
+          end
+
+          # Explicit conversion to Array
+          #
+          # @return [Array]
+          def to_a
+            group.get_members.map { |i| Proxy.new(i) }
+          end
+
+          # Name of the group
+          #
+          # @return [String]
+          def name
+            group.name
+          end
+
+          # @return [String]
+          def inspect
+            "#<OpenHAB::Core::Items::GroupItems::Members #{name} #{map(&:name).inspect}>"
+          end
+          alias_method :to_s, :inspect
+        end
+
+        # Override because we want to send them to the base item if possible
+        %i[command update].each do |method|
+          define_method(method) do |command|
+            return base_item.__send__(method, command) if base_item
+
+            super(command)
+          end
+        end
+
+        #
+        # @!attribute [r] members
+        # @return [Members] Get an Array-like object representing the members of the group
+        #
+        # @see Enumerable
+        #
+        def members
+          Members.new(self)
+        end
+
+        #
+        # @!attribute [r] all_members
+        # @return [Array] Get all non-group members of the group recursively.
+        #
+        # @see Enumerable
+        #
+        def all_members
+          getAllMembers.map { |m| Proxy.new(m) }
+        end
+
+        # give the base item type a chance to format commands
+        # @!visibility private
+        def format_type(command)
+          return super unless base_item
+
+          base_item.format_type(command)
+        end
+
+        private
+
+        # Add base type and function details
+        def type_details
+          r = ""
+          r += ":#{base_item.type}#{base_item.__send__(:type_details)}" if base_item
+          if function && (fn = function.class.java_class.simple_name.upcase) != "EQUALITY"
+            r += ":#{fn}"
+            r += "(#{function.parameters.map(&:inspect).join(",")})" unless function.parameters.empty?
+          end
+          r
+        end
+
+        # Delegate missing methods to {base_item} if possible
+        def method_missing(method, *args, &block)
+          return base_item.__send__(method, *args, &block) if base_item&.respond_to?(method) # rubocop:disable Lint/RedundantSafeNavigation nil responds to :to_a
+
+          super
+        end
+
+        def respond_to_missing?(method, include_private = false)
+          return true if base_item&.respond_to?(method) # rubocop:disable Lint/RedundantSafeNavigation
+
+          super
+        end
+      end
+    end
+  end
+end
+
+# @!parse GroupItem = OpenHAB::Core::Items::GroupItem

data/lib/openhab/core/items/image_item.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "base64"
+require "pathname"
+require "net/http"
+require "marcel"
+
+require_relative "generic_item"
+
+module OpenHAB
+  module Core
+    module Items
+      java_import org.openhab.core.library.items.ImageItem
+
+      #
+      # An {ImageItem} holds the binary image data as its state.
+      #
+      # @!attribute [r] state
+      #   @return [RawType, nil]
+      #
+      # @example Update from a base 64 encode image string
+      #   Image.update("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABAQMAAAAl21bKAAAAA1BMVEUAAACnej3aAAAAAXRSTlMAQObYZgAAAApJREFUCNdjYAAAAAIAAeIhvDMAAAAASUVORK5CYII=")
+      #
+      # @example Update from image bytes and mime type
+      #   Image.update_from_bytes(File.binread(File.join(Dir.tmpdir,'1x1.png')), mime_type: 'image/png')
+      #
+      # @example Update from URL
+      #   Image.update_from_url('https://raw.githubusercontent.com/boc-tothefuture/openhab-jruby/main/features/assets/1x1.png')
+      #
+      # @example Update from File
+      #   Image.update_from_file('/tmp/1x1.png')
+      #
+      # @example Log image data
+      #   logger.info("Mime type: #{Image.state.mime_type}")
+      #   logger.info("Number of bytes: #{Image.state.bytes.length}")
+      #
+      class ImageItem < GenericItem
+        #
+        # Update image from file
+        #
+        # @param [String] file location
+        # @param [String] mime_type of image
+        #
+        #
+        def update_from_file(file, mime_type: nil)
+          file_data = File.binread(file)
+          mime_type ||= Marcel::MimeType.for(Pathname.new(file)) || Marcel::MimeType.for(file_data)
+          update_from_bytes(file_data, mime_type: mime_type)
+        end
+
+        #
+        # Update image from image at URL
+        #
+        # @param [String] uri location of image
+        #
+        #
+        def update_from_url(uri)
+          logger.trace("Downloading image from #{uri}")
+          response = Net::HTTP.get_response(URI(uri))
+          mime_type = response["content-type"]
+          bytes = response.body
+          mime_type ||= detect_mime_from_bytes(bytes: bytes)
+          update_from_bytes(bytes, mime_type: mime_type)
+        end
+
+        #
+        # Update image from image bytes
+        #
+        # @param [String] mime_type of image
+        # @param [Object] bytes image data
+        #
+        #
+        def update_from_bytes(bytes, mime_type: nil)
+          mime_type ||= detect_mime_from_bytes(bytes: bytes)
+          base_64_image = encode_image(mime_type: mime_type, bytes: bytes)
+          update(base_64_image)
+        end
+
+        private
+
+        #
+        # Encode image information in the format required by OpenHAB
+        #
+        # @param [String] mime_type for image
+        # @param [Object] bytes image data
+        #
+        # @return [String] OpenHAB image format with image data Base64 encoded
+        #
+        def encode_image(mime_type:, bytes:)
+          "data:#{mime_type};base64,#{Base64.strict_encode64(bytes)}"
+        end
+
+        #
+        # Detect the mime type based on bytes
+        #
+        # @param [Array] bytes representing image data
+        #
+        # @return [String] mime type if it can be detected, nil otherwise
+        #
+        def detect_mime_from_bytes(bytes:)
+          logger.trace("Detecting mime type from file image contents")
+          Marcel::MimeType.for(bytes)
+        end
+      end
+    end
+  end
+end
+
+# @!parse ImageItem = OpenHAB::Core::Items::ImageItem

data/lib/openhab/core/items/location_item.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "generic_item"
+
+module OpenHAB
+  module Core
+    module Items
+      java_import org.openhab.core.library.items.LocationItem
+
+      #
+      # A LocationItem can be used to store GPS related information, addresses
+      # etc.
+      #
+      # This is useful for location awareness related functions
+      #
+      # @!attribute [r] state
+      #   @return [PointType, nil]
+      #
+      # @example Send point commands
+      #   Location << '30,20'   # latitude of 30, longitude of 20
+      #   Location << '30,20,80' # latitude of 30, longitude of 20, altitude of 80
+      #   Location << PointType.new('40,20')
+      #
+      # @example Determine the distance between two locations
+      #   logger.info "Distance from Location 1 to Location 2: #{Location1.state - Location2.state}"
+      #   logger.info "Distance from Location 1 to Location 2: #{Location1.state - PointType.new('40,20')}"
+      #
+      class LocationItem < GenericItem
+      end
+    end
+  end
+end
+
+# @!parse LocationItem = OpenHAB::Core::Items::LocationItem

data/lib/openhab/core/items/metadata/hash.rb

@@ -0,0 +1,390 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module OpenHAB
+  module Core
+    module Items
+      module Metadata
+        #
+        # {Hash} represents the configuration for a single metadata namespace.
+        #
+        # It implements the entire interface of {::Hash}.
+        #
+        # All keys are converted to strings.
+        #
+        # @!attribute [rw] value
+        #   @return [String] The main value for the metadata namespace.
+        #
+        class Hash
+          java_import org.openhab.core.items.Metadata
+          private_constant :Metadata
+
+          include Enumerable
+
+          extend Forwardable
+          def_delegators :@metadata, :configuration, :hash, :to_s, :uid, :value
+          protected :configuration
+
+          # @!method to_hash
+          #   Implicit conversion to {::Hash}.
+          #   @return [::Hash]
+
+          # Make it act like a Hash; some methods can be handled by
+          # java.util.Map, others we have to convert to a Ruby Hash first, and
+          # still others (mutators) must be manually implemented below.
+          def_delegators :configuration,
+                         :any?,
+                         :default,
+                         :default_proc,
+                         :each,
+                         :each_key,
+                         :each_pair,
+                         :each_value,
+                         :empty?,
+                         :filter,
+                         :flatten,
+                         :has_value?,
+                         :keys,
+                         :length,
+                         :rassoc,
+                         :reject,
+                         :select,
+                         :shift,
+                         :size,
+                         :to_a,
+                         :to_h,
+                         :to_hash,
+                         :value?
+          def_delegators :to_h, :invert, :merge, :transform_keys, :transform_values
+
+          class << self
+            # @!visibility private
+            def from_item(item_name, namespace, value)
+              namespace = namespace.to_s
+              value = case value
+                      when Hash
+                        return value if value.uid.item_name == item_name && value.uid.namespace == namespace
+
+                        [value.value, value.send(:configuration)]
+                      when Array
+                        raise ArgumentError, "Array must contain 2 elements: value, config" if value.length != 2
+
+                        [value.first, (value.last || {}).transform_keys(&:to_s)]
+                      when ::Hash then ["", value.transform_keys(&:to_s)]
+                      else [value, {}]
+                      end
+              new(Metadata.new(org.openhab.core.items.MetadataKey.new(namespace.to_s, item_name), *value))
+            end
+
+            # @!visibility private
+            def from_value(namespace, value)
+              from_item("-", namespace, value)
+            end
+          end
+
+          # @!visibility private
+          def initialize(metadata)
+            @metadata = metadata
+          end
+
+          # @!visibility private
+          def dup
+            new(Metadata.new(org.openhab.core.items.MetadataKey.new(uid.namespace, "-"), value, configuration))
+          end
+
+          # Is this object attached to an actual Item?
+          # @return [true,false]
+          def attached?
+            uid.item_name != "-"
+          end
+
+          # @!attribute [r] item
+          #   @return [GenericItem, nil] The item this namespace is attached to.
+          def item
+            return nil unless attached?
+
+            DSL.items[uid.item_name]
+          end
+
+          # @!visibility private
+          def create
+            NamespaceHash.registry.add(@metadata) if attached?
+          end
+
+          # @!visibility private
+          def commit
+            NamespaceHash.registry.update(@metadata) if attached?
+          end
+
+          # @!visibility private
+          def eql?(other)
+            return true if equal?(other)
+            return false unless other.is_a?(Hash)
+            return false unless value == other.value
+
+            configuration == other.configuration
+          end
+
+          #
+          # Set the metadata value
+          #
+          def value=(value)
+            @metadata = org.openhab.core.items.Metadata.new(uid, value.to_s, configuration)
+            commit
+          end
+
+          # @!visibility private
+          def <(other)
+            if other.is_a?(Hash)
+              return false if attached? && uid == other.uid
+              return false unless value == other.value
+            end
+
+            to_h < other
+          end
+
+          # @!visibility private
+          def <=(other)
+            if other.is_a?(Hash)
+              return true if attached? && uid == other.uid
+              return false unless value == other.value
+            end
+
+            to_h <= other
+          end
+
+          # @!visibility private
+          def ==(other)
+            if other.is_a?(Hash)
+              return false unless value == other.value
+
+              return configuration == other.configuration
+            elsif value.empty? && other.respond_to?(:to_hash)
+              return configuration.to_h == other.to_hash
+            end
+            false
+          end
+
+          # @!visibility private
+          def >(other)
+            if other.is_a?(Hash)
+              return false if attached? && uid == other.uid
+              return false unless value == other.value
+            end
+
+            to_h > other
+          end
+
+          # @!visibility private
+          def >=(other)
+            if other.is_a?(Hash)
+              return true if attached? && uid == other.uid
+              return false unless value == other.value
+            end
+
+            to_h >= other
+          end
+
+          # @!visibility private
+          def [](key)
+            configuration[key.to_s]
+          end
+
+          # @!visibility private
+          def []=(key, value)
+            key = key.to_s
+            new_config = to_h
+            new_config[key] = value
+            replace(new_config)
+            value # rubocop:disable Lint/Void
+          end
+          alias_method :store, :[]=
+
+          # @!visibility private
+          def assoc(key)
+            configuration.assoc(key.to_s)
+          end
+
+          # @!visibility private
+          def clear
+            replace({})
+          end
+
+          # @!visibility private
+          alias_method :compact, :to_h
+
+          # @!visibility private
+          def compact!
+            # no action; impossible to have nil keys
+            self
+          end
+
+          # @!visibility private
+          def compare_by_identity
+            raise NotImplementedError
+          end
+
+          # @!visibility private
+          def compare_by_identity?
+            false
+          end
+
+          # @!visibility private
+          def deconstruct_keys
+            self
+          end
+
+          # @!visibility private
+          def default=(*)
+            raise NotImplementedError
+          end
+
+          # @!visibility private
+          def default_proc=(*)
+            raise NotImplementedError
+          end
+
+          # @!visibility private
+          def delete(key)
+            key = key.to_s
+            new_config = to_h
+            return yield(key) if block_given? && !new_config.key?(key)
+
+            old_value = new_config.delete(key)
+            replace(new_config)
+            old_value
+          end
+
+          # @!visibility private
+          def delete_if(&block)
+            raise NotImplementedError unless block
+
+            replace(to_h.delete_if(block))
+          end
+
+          # @!visibility private
+          def dig(key, *keys)
+            configuration.dig(key.to_s, *keys)
+          end
+
+          # @!visibility private
+          def except(*keys)
+            to_h.except(*keys.map(&:to_s))
+          end
+
+          # @!visibility private
+          def fetch(key, &block)
+            configuration.fetch(key.to_s, &block)
+          end
+
+          # @!visibility private
+          def fetch_values(*keys, &block)
+            configuration.fetch_values(*keys.map(&:to_s), &block)
+          end
+
+          # @!visibility private
+          def keep_if(&block)
+            select!(&block)
+            self
+          end
+
+          # @!visibility private
+          def key(value)
+            rassoc(value)&.first
+          end
+
+          # @!visibility private
+          def key?(key)
+            configuration.key?(key.to_s)
+          end
+          alias_method :include?, :key?
+          alias_method :has_key?, :key?
+          alias_method :member?, :key?
+
+          # @!visibility private
+          def merge!(*others, &block)
+            return self if others.empty?
+
+            new_config = to_h
+            others.each do |h|
+              new_config.merge!(h.transform_keys(&:to_s), &block)
+            end
+            replace(new_config)
+          end
+          alias_method :update, :merge!
+
+          # @!visibility private
+          def reject!(&block)
+            raise NotImplementedError unless block
+
+            r = to_h.reject!(&block)
+            replace(r) if r
+          end
+
+          #
+          # Replace the configuration with a new {::Hash}.
+          #
+          # @param [::Hash] new_config
+          # @return [self]
+          #
+          def replace(new_config)
+            @metadata = org.openhab.core.items.Metadata.new(uid, value, new_config.transform_keys(&:to_s))
+            commit
+            self
+          end
+
+          # @!visibility private
+          def select!(&block)
+            raise NotImplementedError unless block?
+
+            r = to_h.select!(&block)
+            replace(r) if r
+          end
+          alias_method :filter!, :select!
+
+          # @!visibility private
+          def slice(*keys)
+            to_h.slice(*keys.map(&:to_s))
+          end
+
+          # @!visibility private
+          def to_proc
+            ->(k) { self[k] }
+          end
+
+          # @!visibility private
+          def transform_keys!(*args, &block)
+            replace(transform_keys(*args, &block))
+          end
+
+          # @!visibility private
+          def transform_values!(&block)
+            raise NotImplementedError unless block
+
+            replace(transform_values(&block))
+          end
+
+          # @!visibility private
+          def values
+            configuration.values.to_a
+          end
+
+          # @!visibility private
+          def values_at(*keys)
+            configuration.values_at(*keys.map(&:to_s))
+          end
+
+          # @!visibility private
+          def inspect
+            return to_h.inspect if value.empty?
+            return value.inspect if configuration.empty?
+
+            [value, to_h].inspect
+          end
+          alias_method :to_s, :inspect
+        end
+      end
+    end
+  end
+end