hokusai-zero 0.1.1

data/ui/src/hokusai/automation/converters/selector_converter.rb

@@ -0,0 +1,61 @@
+require_relative "../selector"
+
+module Hokusai::Automation
+  module Converters
+    module SelectorConverter
+      def self.parse_selectors(selector)
+        final = []
+        scanner = StringScanner.new(selector)
+
+        while !scanner.eos?
+          if node = scan_node(scanner)
+            id = scan_id(scanner)
+            classes = scan_classes(scanner)
+            final << Selector.new(node, id, classes)
+
+            scan_space(scanner)
+          elsif id = scan_id(scanner)
+            classes = scan_classes(scanner)
+            final << Selector.new(nil, id, classes)
+
+            scan_space(scanner)
+          elsif classes = scan_classes(scanner)
+            final << Selector.new(nil, nil, classes)
+
+            scan_space(scanner)
+          else
+            scanner.terminate
+
+            if scanner.rest.empty?
+              scanner.terminate
+            else
+              raise Automation::Error.new("Error Scanning: Improperly formatted selector: #{scanner.rest}")
+            end
+          end
+        end
+
+        final
+      end
+
+      private
+
+      def self.scan_id(scanner)
+        scanner.scan(/\#([A-Za-z0-9-_]+)/)
+        scanner[1]
+      end
+
+      def self.scan_classes(scanner)
+        scanner.scan(/((\.[A-Za-z0-9-_]+)+)/)
+        scanner[1]&.[](1..-1)&.split(".")
+      end
+
+      def self.scan_node(scanner)
+        scanner.scan(/[A-Za-z0-9-_]+/)
+      end
+
+      def self.scan_space(scanner)
+        scanner.scan(/\s*/)
+      end
+    end
+  end
+end

data/ui/src/hokusai/automation/driver.rb

@@ -0,0 +1,54 @@
+require_relative "./driver_commands/base"
+require_relative "./driver_commands/get_attribute"
+require_relative "./driver_commands/invoke"
+require_relative "./driver_commands/locate"
+require_relative "./driver_commands/trigger_keyboard"
+require_relative "./driver_commands/trigger_mouse"
+require_relative "./driver_command_queue"
+
+module Hokusai
+  module Automation
+    class Driver
+      attr_reader :server, :queue, :results
+
+      def initialize
+        @queue = DriverCommandQueue.new
+        @results = {}
+        @server = Hokusai::Automation::Server
+      end
+
+      def serve(*args)
+        @server.start(*args, driver: self)
+      end
+
+      def stop
+        @server.stop
+      end
+
+      def complete
+        queue.completed(results)
+      end
+      
+      # Adds a driver command to the queue to be executed
+      # 
+      # Commands process one-by-one on each iteration of the
+      # UI loop.  
+      # 
+      # When a command is finished, its result will be populated in `#results`
+      def execute(command)
+        queue.commands << command
+      end
+
+      # Process a command with the given UI state
+      # 
+      # Results will added to the results hash and picked up by the current server request
+      # 
+      # *  `blocks` is a tuple containing a block and its parent
+      # *  `canvas` is the current canvas being painted
+      # *  `input` is the application input state for this loop iteration
+      def process(blocks, canvas, input)
+        queue.process(blocks, canvas, input)
+      end
+    end
+  end
+end

data/ui/src/hokusai/automation/driver_command_queue.rb

@@ -0,0 +1,50 @@
+module Hokusai::Automation
+  # A queue of `DriverCommand`
+  # 
+  # The queue is processed async on each iteration of the event loop
+  class DriverCommandQueue
+    attr_accessor :commands
+
+    def initialize
+      @commands = []
+    end
+
+    def completed(results)
+      if command = commands[0]
+        # command was added in the middle of a render cycle, don't complete it.
+        return if command.waiting?
+
+        if value = command.on_complete
+          case value
+          when ::Hokusai::Automation::Error
+            results[command.request_id] = [command, value]
+          else
+            results[command.request_id] = [command, value]
+          end
+        end
+
+        if command.done?
+          
+          commands.shift
+        end
+      end
+    end
+
+    # Processes any availabe commands in the queue
+    # 
+    # Returns a Tuple containing the command and it's wrapped return value
+    def process(blocks, canvas, input)
+      return nil if commands.empty?
+
+      command = commands[0]
+
+      # wait for the start of the render loop
+      # 
+      # if there is no parent, execute the command
+      return if !blocks[1].nil? && command.waiting?
+
+      command.pending! if command.waiting?
+      command.execute(blocks, canvas, input)
+    end
+  end
+end

data/ui/src/hokusai/automation/driver_commands/base.rb

@@ -0,0 +1,79 @@
+module Hokusai::Automation
+  module DriverCommands
+    class Base 
+      attr_accessor :request_id, :status, :last_parent
+      attr_reader :state
+
+      [:waiting, :pending, :done].each do |key|
+        define_method("#{key}?") do
+          status == key
+        end
+
+        define_method("#{key}!") do
+          self.status = key
+        end
+      end
+
+      def initialize(hash)
+        @state = hash
+        @last_parent = nil
+      end
+
+      def status
+        @status ||= :wait
+      end
+
+      def request_id
+        @request_id ||= SecureRandom.uuid
+      end
+
+      def on_complete(&block)
+        raise NotImplementedError.new("Must implement #{self.class}#on_complete")
+      end
+
+      def execute(blocks, canvas, input)
+        raise NotImplementedError.new("Must implement #{self.class}#execute")
+      end
+
+      def matches_block(block)
+        return false unless block.node.portal
+        
+        if location == block.node.portal.uuid.to_s
+          
+          return true
+        end
+
+        false
+      end
+
+      def matches_blocks(blocks)
+        if matches_block(blocks[0]) || (last_parent == blocks[1] && !last_parent.nil?)
+          self.last_parent = blocks[0]
+
+          return true
+        end
+
+        false
+      end
+
+
+      def mouse_center(canvas, input)
+        x = canvas.x + (canvas.width / 2)
+        y = canvas.y + (canvas.height / 2)
+  
+        mouse_move(x, y, input)
+      end
+
+      def mouse_move(x, y, input)
+        LibHokusai.hoku_input_set_mouse_position(input, vec2(x, y))
+      end
+
+      private
+  
+      # Returns an HmlVec2 from {x,y}
+      def vec2(x, y)
+        LibHokusai::HmlVec2.create(x, y)
+      end
+    end
+  end
+end

data/ui/src/hokusai/automation/driver_commands/get_attribute.rb

@@ -0,0 +1,41 @@
+module Hokusai::Automation
+  module DriverCommands
+    class GetAttribute < Base      
+      attr_accessor  :value
+
+      def initialize(state)
+        @value = nil
+
+        super
+      end
+
+      def location
+        state[:uuid]
+      end
+
+      def attribute_name
+        state[:attribute_name]
+      end
+
+      def on_complete
+        done!
+
+        if value.nil?
+          return ::Hokusai::Automation::Error.new("Attribute #{attribute_name} not found")
+        end
+
+        return value
+      end
+
+      def execute(blocks, canvas, input)
+        return unless matches_block(blocks[0])
+
+        Log.debug { "Props: #{blocks[0].node.meta.props}".colorize(:yellow) }
+        
+        attribute = blocks[0].node.meta.props[attribute_name.to_sym]
+
+        self.value = attribute
+      end
+    end
+  end
+end

data/ui/src/hokusai/automation/driver_commands/invoke.rb

@@ -0,0 +1,33 @@
+module Hokusai::Automation
+  module DriverCommands
+    class Invoke < Base
+      attr_accessor :value
+
+      def location
+        state[:uuid]
+      end
+
+      def method
+        state[:method]
+      end
+
+      def initialize(hash)
+        @value = nil
+
+        super
+      end
+
+      def on_complete
+        return value if done?
+      end
+
+      def execute(block, canvas, input)
+        return unless matches_block(blocks[0])
+
+        self.value = blocks[0].public_send(method)
+
+        done!
+      end   
+    end
+  end
+end

data/ui/src/hokusai/automation/driver_commands/locate.rb

@@ -0,0 +1,48 @@
+require_relative "../converters/selector_converter"
+
+module Hokusai::Automation
+  module DriverCommands
+    class Locate < Base    
+      attr_reader :matches
+
+      def initialize(hash)
+        @matches = []
+        @selectors = nil
+
+        super
+      end
+
+      def on_complete
+        return if waiting?
+        
+        done!
+
+        return ::Hokusai::Automation::Error.new("No matches found") if matches.empty?
+
+        matches.last
+      end
+
+      def selectors
+        @selectors ||= Converters::SelectorConverter.parse_selectors(state[:selector])
+      end
+
+      def execute(blocks, canvas, input)
+        if selector = selectors.shift
+          if selector.matches(blocks[0])
+            Log.debug {"Location match! #{selector}".colorize(:light_magenta)}
+
+            portal = blocks[0].node.portal
+            
+            Log.debug { "uuid: #{portal.uuid.to_s}".colorize(:light_magenta) }
+
+            matches << portal.uuid.to_s
+
+            selectors.unshift(selector) if selectors.empty?
+          else
+            selectors.unshift(selector)
+          end
+        end
+      end      
+    end
+  end
+end

data/ui/src/hokusai/automation/driver_commands/trigger_keyboard.rb

@@ -0,0 +1,94 @@
+module Hokusai::Automation
+  module DriverCommands
+    class TriggerKeyboard < Base
+      attr_reader :exception
+
+      def initialize(state)
+        @exception = nil
+
+        super
+      end
+
+      def location
+        state[:uuid]
+      end
+
+      def keys
+        @keys ||= KeysTranscoder.decode(state[:keys])
+      end
+
+      def on_complete
+        if keys.empty?
+          done!
+        end
+
+        return exception || true
+      end
+
+      def execute(blocks, canvas, input)
+        return unless matches_block(blocks[0])
+
+        Log.info { "Trigger keypress on #{blocks[0].class}".colorize(:cyan) }
+
+        decode_key = keys.shift
+
+        mouse_center(canvas, input)
+        state = LibHokusai::HmlInputMouseButton.create(clicked: true)
+        LibHokusai.hoku_input_mouse_set_button(input, state, 0)
+
+        begin
+          key_results = to_hml_keygroup(decode_key)
+
+          LibHokusai.hoku_input_keyboard_start(input)
+
+          key_results.each do |key|
+            Log.info { "populating #{key}"}
+
+            LibHokusai.hoku_input_keyboard_set_key(input, key, true)
+          end
+
+          LibHokusai.hoku_input_keyboard_stop(input)
+        rescue Automation::Error => ex
+          keys.clear
+          self.exeception = ex
+          
+          done!
+        end
+      end
+
+      # Transforms a DecodedKey to an array of `LibHokusai::HmlInputKey`
+      def to_hml_keygroup(decode_key)
+        key_group = []
+
+        case decode_key
+        when Array
+          decode_key.each do |key|
+            if hml_key = CODE_TO_HML_KEY[key]
+              key_group << hml_key
+            else
+              raise Automation::Exception.new("Error translating key to HmlInput: #{key} not found")
+            end
+          end
+        else
+          if hml_key CODE_TO_HML_KEY[decode_key]
+            key_group << hml_key
+          else
+            raise Automation::Exception.new("Error translating key to HmlInput: #{key} not found")
+          end
+        end
+
+        key_group
+      end
+
+      def to_hml_keys
+        hml_keys = []
+
+        keys.each do |decode_key|
+          hml_keys << to_hml_keygroup(decode_key)
+        end
+
+        hml_keys
+      end
+    end
+  end
+end

data/ui/src/hokusai/automation/driver_commands/trigger_mouse.rb

@@ -0,0 +1,213 @@
+module Hokusai::Automation
+  module DriverCommands
+    module MouseMethods
+      def trigger_mouse(input, **args)
+        state = LibHokusai::HmlInputMouseButton.create(**args)
+
+        LibHokusai.hoku_input_mouse_set_button(input, state, button)
+      end
+    end
+
+    class TriggerMouseBase < Base
+      include MouseMethods
+
+      attr_accessor :value
+    
+      def initialize(hash)
+        @value = false
+
+        super
+      end
+
+      def location
+        state[:uuid]
+      end
+
+      def button
+        state[:button]
+      end
+
+      def on_complete
+        return value if done?
+
+        return Automation::Error.new("Could not locate block")
+      end
+    end
+
+    class TriggerMouseDown < TriggerMouseBase
+      def execute(blocks, canvas, input)
+        if matches_blocks(blocks)
+          
+          mouse_center(canvas, input)
+          trigger_mouse(input, down: true)
+
+          self.value = true
+          
+          done!
+        end
+      end
+    end
+
+    class TriggerMouseUp < TriggerMouseBase
+      def execute(blocks, canvas, input)
+        if matches_blocks(blocks)
+          
+          mouse_center(canvas, input)
+          trigger_mouse(input, up: true)
+
+          self.value = true
+          
+          done!
+        end
+      end
+    end
+
+    class TriggerMouseClick < TriggerMouseBase
+      def execute(blocks, canvas, input)
+        if matches_blocks(blocks)
+          
+          mouse_center(canvas, input)
+          trigger_mouse(input, clicked: true)
+
+          self.value = true
+          
+          done!
+        end
+      end
+    end
+
+    class TriggerMouseRelease < TriggerMouseBase
+      def execute(blocks, canvas, input)
+        if matches_blocks(blocks)
+          
+          mouse_center(canvas, input)
+          trigger_mouse(input, released: true)
+
+          self.value = true
+          
+          done!
+        end
+      end
+    end
+
+    class TriggerMouseHover < Base
+      def location
+        state[:uuid]
+      end
+
+      def on_complete
+        return true if done?
+
+        return Automation::Error.new("Could not locate block")
+      end
+
+      def execute(blocks, canvas, input)
+        if matches_block(blocks[0])
+          mouse_center(canvas, input)
+
+          done!
+        end
+      end
+    end
+
+    class TriggerMouseMove < Base
+      def x
+        state[:x]
+      end
+
+      def y
+        state[:y]
+      end
+
+      def on_complete
+        return true
+      end
+
+      def execute(blocks, canvas, input)
+        mouse_move(x, y, input) unless done?
+
+        done!
+      end
+    end
+
+    class TriggerMouseDrag < Base
+      include MouseMethods
+
+      attr_accessor :dragging, :cursory_y, :button
+
+      def initialize(hash)
+        @dragging = false
+        @cursory_y = 0.0
+        @button = 0
+
+        super
+      end
+
+      def location
+        state[:uuid]
+      end
+
+      def x
+        state[:x]
+      end
+
+      def y
+        state[:y]
+      end
+
+      def on_complete
+        return false if dragging
+
+        true
+      end
+
+      def execute(blocks, canvas, input)
+        if matches_block(blocks[0])
+          local_x = x || canvas.x + (canvas.width / 2.0)
+          local_y = y || canvas.y + (canvas.height / 2.0)
+
+          if cursor_y < local_y && dragging
+            trigger_mouse(input, down: true)
+            mouse_move(local_x, cursor_y, input)
+
+            self.cursor_y += 2.0
+          elsif !dragging
+            trigger_mouse(input, clicked: true)
+
+            self.dragging = true
+          else
+            self.dragging = false
+            
+            done!
+          end
+        end
+      end
+    end
+
+    class TriggerMouseWheel < Base
+      def location
+        state[:uuid]
+      end
+
+      def scroll_amount
+        state[:scroll_amount]
+      end
+
+      def on_complete
+        return true if done?
+
+        return Automation::Error.new("Could not locate block")
+      end
+
+      def execute(blocks, canvas, input)
+        if matches_block(blocks[0])
+          mouse_center(canvas, input)
+          LibHokusai.hoku_input_mouse_set_scroll(input, scroll_amount)
+
+
+          done!
+        end
+      end
+    end
+  end
+end