macrohub 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ba95c07689c92cdb6df0081466aea3961da3eee30e7217f4d2077bca43984084
+  data.tar.gz: 3f860c4ba1baa27d5711b37a1443619d3c0418d27f0f3f64f7c8b204a5031ac1
+SHA512:
+  metadata.gz: 6181da5d0d83f8a519ae29836a606376590a797fb97d8d3e0ac90cea8eec3bc9132703c6c39e09a2f9be2f675360115555c8be14b3bba3049323050e87fcd41c
+  data.tar.gz: 83b5c8505b963d25f55096fb59f9c5aaaad58cd3aea47f9ac46dbaea50baf05f278c526e157b600641b2f8c3acbb05f233e13e73aefd63b45f7f942ee3249edd

data/lib/macrohub.rb

@@ -0,0 +1,572 @@
+#!/usr/bin/env ruby
+
+# file: macrohub.rb
+
+require 'rowx'
+require 'app-routes'
+require 'rxfhelper'
+require 'chronic_between'
+
+# This file includes the following classes:
+#
+#      * SayAction
+#      * WebhookAction
+#      * MotionTrigger
+#      * FrequencyConstraint
+#      * TimeConstraint
+#      * TriggersNlp    - selects the trigger to use
+#      * ActionsNlp     - selects the action to use
+#      * ConstraintsNlp - selects the constraint to use
+#      * Macro    - contains the triggers, actions, and constraints
+#      * MacroHub - contains the macros
+
+class SayAction
+
+  def initialize(s=nil, msg: s)
+    @s  = msg
+  end
+  
+  def invoke()
+    "say: %s" % @s
+  end
+  
+  def to_node()
+    Rexle::Element.new(:action, attributes: {type: :say, text: @s})
+  end        
+  
+  def to_rowx()
+    "action: say '%s'" %  @s
+  end    
+
+end
+
+class WebhookAction
+  
+  attr_accessor :url
+
+  def initialize(idx=nil, id: idx, url: '127.0.0.1', env: {debug: false})
+    
+    @name, @url = id, url
+    
+  end
+  
+  def invoke()
+    "webhook: %s" % @url
+  end
+  
+  def to_node()
+    Rexle::Element.new(:action, \
+                        attributes: {type: :webhook, name: @name, url: @url})
+  end    
+  
+  def to_rowx()
+    s = "action: webhook %s" %  @name
+    s += "\n  url: %s" % @url
+  end
+
+end
+
+class MotionTrigger
+
+  attr_reader :location, :type
+  
+  def initialize(location: nil)
+    
+    @location = location
+    @type = :motion
+    
+  end
+  
+  def match?(detail)
+
+    puts 'inside MotionTrigger#match' if $debug
+    location = detail[:location]
+    
+    if location then
+      
+      @location.downcase == location.downcase
+      
+    else
+      return false
+    end
+    
+  end  
+  
+  def to_node()
+    Rexle::Element.new(:trigger, attributes: {type: :motion, 
+                                              location: @location})
+  end
+  
+  def to_rowx()
+    "trigger: Motion detected in the %s" %  @location
+  end        
+
+end
+
+class FrequencyConstraint      
+    
+  def initialize(freqx, freq: freqx)
+    
+    @freq = freq
+    @counter = 0
+    @interval = 60
+  end
+  
+  def counter()
+    @counter
+  end
+  
+  def increment()
+    @counter += 1
+  end
+  
+  def match?()
+    @counter < @freq
+  end
+  
+  def reset()
+    puts 'resetting' if $debug
+    @counter = 0
+  end
+  
+  def to_node()
+    Rexle::Element.new(:constraint, \
+                        attributes: {type: :frequency, freq: @freq})      
+  end
+  
+  def to_rowx()
+    
+    freq = case @freq
+    when 1
+      'Once'
+    when 2
+      'Twice'
+    else
+      "Maximum %s times" % @freq
+    end
+    
+    "constraint: %s" %  freq
+
+  end
+  
+end
+
+class TimeConstraint    
+  
+  attr_accessor :time
+  
+  def initialize(timex=nil, times: timex, time: timex)
+    
+    @time = times || time
+    
+  end
+  
+  def match?(detail)
+    
+    if $debug then
+      puts 'inside TimeConstraint#match?' 
+      puts 'detail: ' + detail.inspect
+      puts '@time: ' + @time.inspect
+    end
+    
+    ChronicBetween.new(@time).within?(detail[:time])
+    
+  end  
+      
+  def to_node()
+    Rexle::Element.new(:constraint, \
+                        attributes: {type: :time, time: @time})      
+  end    
+  
+  def to_rowx()            
+    "constraint: %s" %  @time
+  end    
+      
+end
+
+
+
+
+class TriggersNlp
+  include AppRoutes
+
+  attr_reader :to_type
+
+  def initialize()
+
+    super()
+
+    params = {}
+    puts 'inside Trigger'
+    puts 'params: ' + params.inspect
+    triggers(params)
+
+  end
+
+  protected
+
+  def triggers(params) 
+    
+    puts 'inside triggers'
+
+    # e.g. Motion detected in the kitchen
+    #
+    get /motion detected in the (.*)/i do |location|
+      puts 'motion detection trigger' if $debug
+      [MotionTrigger, {location: location}]
+    end
+
+  end
+
+  private
+
+  alias find_trigger run_route
+
+end
+
+class ActionsNlp
+  include AppRoutes
+
+  def initialize()
+
+    super()
+
+    params = {}
+    actions(params)
+
+  end
+
+  protected
+
+  def actions(params) 
+
+    puts 'inside actions'
+    # e.g. Say 'Good morning'
+    #
+    get /say ['"]([^'"]+)/i do |s|
+      puts 's: ' + s.inspect if $debug
+      [SayAction, {msg: s} ]
+    end
+    
+    # e.g. webhook entered_kitchen
+    #
+    get /webhook (.*)/i do |name|
+      [WebhookAction, {id: name }]
+    end      
+    
+    get /.*/ do
+      puts 'action unknown' if $debug
+      []
+    end
+
+  end
+
+  private
+
+  alias find_action run_route
+
+end
+
+class ConstraintsNlp
+  include AppRoutes
+  
+  
+  def initialize()
+    
+    super()
+    
+    params = {}
+    constraints(params)
+    
+  end
+  
+  protected
+
+  def constraints(params) 
+
+    puts 'inside constraints' if $debug
+    # e.g. Between 8am and 10am
+    #
+    get /^between (.*)/i do |s|
+      [TimeConstraint,  {time: s}]
+    end
+    
+    get /^on a (.*)/i do |s|
+      [TimeConstraint, {time: s}]
+    end
+    
+    get /^(after .*)/i do |s|
+      [TimeConstraint, {time: s}]
+    end      
+    
+    get /^(#{(Date::DAYNAMES + Date::ABBR_DAYNAMES).join('|')}$)/i do |s|
+      [TimeConstraint, {time: s}]
+    end    
+    
+    get /^once only|only once|once|one time|1 time$/i do |s|
+      [FrequencyConstraint, {freq: 1}]
+    end
+    
+    get /^twice only|only twice|twice|two times|2 times$/i do |s|
+      [FrequencyConstraint, {freq: 2}]
+    end
+    
+    get /^(Maximum|Max|Up to) ?three times|3 times$/i do |s|
+      [FrequencyConstraint, {freq: 3}]
+    end                    
+    
+    get /^(Maximum|Max|Up to) ?four times|4 times$/i do |s|
+      [FrequencyConstraint, {freq: 4}]
+    end                          
+
+  end
+
+  private
+
+  alias find_constraint run_route    
+end
+
+class Macro
+
+  attr_accessor :title, :env
+  attr_reader :triggers, :actions, :constraints
+
+  def initialize(node, title: '')
+
+    @title = title
+
+    @actions = []
+    @triggers = []
+    @constraints = []
+
+  end
+
+  def import_xml(node)
+    
+    @title = node.text('macro')
+
+    if node.element('triggers') then
+      
+      triggers = {motion: MotionTrigger, timer: TimerTrigger}
+      
+      # level 2
+      @triggers = node.xpath('triggers/*').map do |e| 
+
+        puts 'e.name: ' + e.name.inspect if $debug
+        triggers[e.name.to_sym].new(e.attributes.to_h)
+
+      end
+
+      actions = {say: SayAction, webhook: WebhookAction}
+      
+      @actions = node.xpath('actions/*').map do |e|
+        
+        actions[e.name.to_sym].new(e.attributes.to_h)
+        
+      end
+      
+      constraints = {time: TimeConstraint, frequency: FrequencyConstraint}
+
+      @constraints = node.xpath('constraints/*').map do |e|
+
+        puts 'before Constraints.new' if $debug
+        constraints[e.name.to_sym].new(e.attributes.to_h)
+        
+      end
+
+    else
+
+      # Level 1
+      
+      tp = TriggersNlp.new      
+      
+      @triggers = node.xpath('trigger').map do |e|
+        
+        r = tp.find_trigger e.text
+        
+        if r then
+          r[0].new(r[1])
+        end
+        
+      end
+      
+      ap = ActionsNlp.new      
+      
+      @actions = node.xpath('action').map do |e|
+        
+        r = ap.find_action e.text
+        
+        if r then
+          
+          a = e.xpath('item/*')
+          
+          h = if a.any? then
+            a.map {|node| [node.name.to_sym, node.text.to_s]}.to_h
+          else
+            {}
+          end
+          
+          r[0].new(r[1].merge(h))
+        end
+        
+      end
+            
+      cn = ConstraintsNlp.new      
+      
+      @constraints = node.xpath('constraint').map do |e|
+
+        puts 'constraint e: ' + e.xml.inspect
+        r = cn.find_constraint e.text
+        
+        puts 'r: ' + r.inspect if $debug
+        
+        if r then
+          r[0].new(r[1])
+        end
+        
+      end        
+
+    end
+  end
+  
+  def match?(triggerx, detail={} )
+                
+    if @triggers.any? {|x| x.type == triggerx and x.match?(detail) } then
+      
+      if $debug then
+        puts 'checking constraints ...' 
+        puts '@constraints: ' + @constraints.inspect
+      end
+      
+      if @constraints.all? {|x| x.match?($env.merge(detail)) } then
+      
+        true
+        
+      else
+
+        return false
+        
+      end
+      
+    end
+    
+  end
+  
+  def run()
+    @actions.map(&:invoke)
+  end  
+  
+  def to_node()
+    
+    if $debug then
+      puts 'inside to_node' 
+      puts '@title: ' + @title.inspect
+    end
+    
+    e = Rexle::Element.new(:macro, attributes: {title: @title})
+    
+    e.add node_collection(:triggers, @triggers)
+    e.add node_collection(:actions, @actions)
+    e.add node_collection(:constraints, @constraints)
+    
+    return e
+  end
+  
+  def to_rowx()
+    
+    s = "macro: %s\n\n" % @title
+    s + [@triggers, @actions, @constraints]\
+        .map {|x| x.collect(&:to_rowx).join("\n")}.join("\n")
+  end
+  
+  private
+  
+  def node_collection(name, a)
+    
+    if $debug then
+      puts 'inside node_collection name: ' + name.inspect
+      puts 'a: ' + a.inspect
+    end
+    
+    e = Rexle::Element.new(name)
+    a.each do |x|
+      
+      puts 'x: ' + x.inspect if $debug
+      e.add x.to_node
+
+    end
+    
+    return e
+    
+  end
+  
+end
+
+class MacroHub
+
+  attr_reader :macros
+
+  def initialize(obj=nil)
+    
+    if obj then
+      
+      s, _ = RXFHelper.read(obj)    
+      
+      if  s[0] == '<'
+        import_xml(s)
+      else        
+        import_xml(RowX.new(s.gsub(/^#.*/,'')).to_xml)
+      end
+      
+    else
+
+      @macros = []
+
+    end
+  end
+
+  def import_xml(raws)
+   
+    s = RXFHelper.read(raws).first
+    puts 's: ' + s.inspect if $debug
+    doc = Rexle.new(s)
+    puts 'after doc' if $debug
+    
+    @macros = doc.root.xpath('item').map do |node|
+          
+      macro = Macro.new node.text('macro')
+      macro.import_xml(node)
+      macro
+      
+    end
+
+  end
+
+  def to_doc()
+    
+    doc = Rexle.new('<macros/>')      
+    
+    @macros.each do |macro|  
+      puts 'macro: ' + macro.inspect if $debug
+      doc.root.add macro.to_node
+    end
+    
+    return doc
+    
+  end
+  
+  def to_rowx()
+    
+    s = ''
+    s += "title: %s\n%s\n\n" % [@title, '-' * 50] if @title
+    s += @macros.collect(&:to_rowx).join("\n\n#{'-'*50}\n\n")
+    
+  end
+  
+  alias to_s to_rowx
+  
+  def to_xml()
+    to_doc.xml pretty: true
+  end
+  
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: macrohub
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- James Robertson
+autorequire: 
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIEXjCCAsagAwIBAgIBATANBgkqhkiG9w0BAQsFADAsMSowKAYDVQQDDCFnZW1t
+  YXN0ZXIvREM9amFtZXNyb2JlcnRzb24vREM9ZXUwHhcNMjAwODE4MjAzMzEwWhcN
+  MjEwODE4MjAzMzEwWjAsMSowKAYDVQQDDCFnZW1tYXN0ZXIvREM9amFtZXNyb2Jl
+  cnRzb24vREM9ZXUwggGiMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQCpxMPq
+  78/MXnTnNIR4r4w8nLvnmiI4+FQdKXM3B+4DtwOD9IYSoJvA0HvEAWaVRpCTNVqf
+  PofbiC3gtiN7fxr8TnuAoY45nm30E7iqOFZvRuHK3Ss9Lrw706yA0532QT3dctzU
+  /QpwjYTOxa1CPH2K0mudFJmgzthY22z3BSi8mgOCEcfXGkh2xmTXzxg8yIp62I5T
+  PzdH43Jpfh7goclqaMZqpg7C06vXpFfQJcy+AMdiSPgrowuJ0WIMK3aQof7lfFPa
+  f+l1rP2eJE/DGPwFDYNqFp5hgYk2N7WiSlp7C7rL/d7KclvXy7lVwOj0uO3MUQPe
+  a5Tyx+9KnXwFFGbi1q3IdrECfGnNeo70jd0mMjbSfeFPlRiALXKI4Sy3Gp1oNhsI
+  sw3epDAap/6TMaqaJbCHHxqk232BX56brcq71v/tJ1QLtK4kss5zir2S7WtT8EfF
+  Csr2KXHBn4yVQlTTvmTQohB2kTkuCQkvYLEtNhH3eJAGPufH83jz2kaW70cCAwEA
+  AaOBijCBhzAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQUVfxui/u3
+  RFnJbdwUpdKC7VGDNXgwJgYDVR0RBB8wHYEbZ2VtbWFzdGVyQGphbWVzcm9iZXJ0
+  c29uLmV1MCYGA1UdEgQfMB2BG2dlbW1hc3RlckBqYW1lc3JvYmVydHNvbi5ldTAN
+  BgkqhkiG9w0BAQsFAAOCAYEAphrYf3LYTmBQtbFJs5w4GgcBNQWSsLrUdeQKP+zy
+  KIVH03WEZm3A0Z5bFBYcLUu7ovp18w6fRIf3PaLk11vVrj2TzuwosT0VoNpeLKQk
+  HITIJkITbee6UFOmg7bvXiwQRNEbiaFhvNid+hIBg93TgbcaiVaXTssRb7diSU29
+  CNgBgY3DuwiS4YtcKim7T5OMqgw6IxvHR86MiE2S9DC36WTxb6bztJs6UCfboecM
+  1GPnqPHri4Gbe9Nx1n0Y/pnQeXUAeetKisk1ry/TeQAbIxSGm7i0xqGFNWw3n6I5
+  KDpDkFCLQnCiyY8s11MYeaU6IsEJtnS7gth+tswkSXo83vwlFzsd2qrGyvFTtdoD
+  v98JCJNEFoLYGkFaAE+AOUJLcRANqZGgsBF5pRg91h0/U92CIMqAP3lAJcudEm7v
+  3fO1S1r6TwHl52rWjJPDVGgq1Xy+wZgNc33Y5Mps7yaLvVH+GmCtOwmn2WNJ9sxH
+  K6cWFZZoUVgD1xtNkydgCYhq
+  -----END CERTIFICATE-----
+date: 2020-08-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rowx
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: app-routes
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.19
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.19
+- !ruby/object:Gem::Dependency
+  name: rxfhelper
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: chronic_between
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+description: 
+email: james@jamesrobertson.eu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/macrohub.rb
+homepage: https://github.com/jrobertson/macrohub
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Experimental gem to create macros with the aim to simulate home automation.
+test_files: []