deskbot 0.1.0

data/ext/deskbot/src/mouse.rs

@@ -0,0 +1,55 @@
+extern crate autopilot;
+use std::collections::HashMap;
+
+fn button(symbol: String) -> autopilot::mouse::Button {
+    match symbol.as_str() {
+        "left" => autopilot::mouse::Button::Left,
+        "middle" => autopilot::mouse::Button::Middle,
+        "right" => autopilot::mouse::Button::Right,
+        _ => panic!("Invalid button"),
+    }
+}
+
+fn scroll_direction(symbol: String) -> autopilot::mouse::ScrollDirection {
+    match symbol.as_str() {
+        "up" => autopilot::mouse::ScrollDirection::Up,
+        "down" => autopilot::mouse::ScrollDirection::Down,
+        _ => panic!("Invalid scroll direction"),
+    }
+}
+
+pub fn location() -> HashMap<String, f64> {
+    let point = autopilot::mouse::location();
+    return HashMap::from([("x".to_string(), point.x), ("y".to_string(), point.y)]);
+}
+
+pub fn move_to(x: f64, y: f64) -> bool {
+    let command = autopilot::mouse::move_to(autopilot::geometry::Point::new(x, y));
+    match command {
+        Ok(_) => true,
+        Err(_) => false,
+    }
+}
+
+pub fn smooth_move(x: f64, y: f64, duration: Option<f64>) -> bool {
+    let command = autopilot::mouse::smooth_move(autopilot::geometry::Point::new(x, y), duration);
+
+    match command {
+        Ok(_) => true,
+        Err(_) => false,
+    }
+}
+
+pub fn toggle(_button: String, down: bool) -> () {
+    let button = button(_button);
+    autopilot::mouse::toggle(button, down);
+}
+
+pub fn click(_button: String, delay_ms: Option<u64>) -> () {
+    let button = button(_button);
+    autopilot::mouse::click(button, delay_ms);
+}
+
+pub fn scroll(direction: String, clicks: u32) -> () {
+    autopilot::mouse::scroll(scroll_direction(direction), clicks);
+}

data/ext/deskbot/src/screen.rs

@@ -0,0 +1,34 @@
+extern crate autopilot;
+use std::collections::HashMap;
+
+pub fn get_color(x: f64, y: f64) -> Option<Vec<u8>> {
+    let color = autopilot::screen::get_color(autopilot::geometry::Point::new(x, y));
+    match color {
+        Ok(color) => Some(color.0.to_vec()),
+        Err(_) => None
+    }
+}
+
+pub fn size() -> HashMap<String, f64> {
+    let size = autopilot::screen::size();
+
+    HashMap::from([
+        ("width".to_string(), size.width),
+        ("height".to_string(), size.height)
+    ])
+}
+
+pub fn scale() -> f64 {
+    autopilot::screen::scale()
+}
+
+pub fn is_point_visible(x: f64, y: f64) -> bool {
+    let point = autopilot::geometry::Point::new(x, y);
+    autopilot::screen::is_point_visible(point)
+}
+
+pub fn is_rect_visible(x: f64, y: f64, width: f64, height: f64) -> bool {
+    let point = autopilot::geometry::Point::new(x, y);
+    let size = autopilot::geometry::Size::new(width, height);
+    autopilot::screen::is_rect_visible(autopilot::geometry::Rect::new(point, size))
+}

data/lib/deskbot/area.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Deskbot
+  class Area < Dry::Struct
+    attribute :x, Types::Float
+    attribute :y, Types::Float
+    attribute :width, Types::Float
+    attribute :height, Types::Float
+
+    transform_keys(&:to_sym)
+  end
+end

data/lib/deskbot/bitmap.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Deskbot
+  class Bitmap
+    include Dry::Monads[:result]
+    include Dry::Matcher.for(
+      :find_color,
+      :find,
+      with: Dry::Matcher::ResultMatcher
+    )
+
+    Rgba = Types::Array
+      .of(Types::Integer.constrained(gteq: 0, lteq: 255))
+      .constrained(size: 4)
+
+    def initialize(provider)
+      @provider = provider
+    end
+
+    def save(image_path)
+      @provider.save(Types::String[image_path])
+    end
+
+    def bounds
+      Area.new(@provider.bounds)
+    end
+
+    def color_at(x, y) # rubocop:disable Naming/MethodParameterName
+      red, green, blue, alpha = @provider.color_at(x, y)
+      Color.new(red:, green:, blue:, alpha:)
+    end
+
+    def eql?(image_path, tolerance: nil)
+      @provider.bitmap_eq(
+        Types::String[image_path],
+        Types::Float.optional[tolerance]
+      )
+    end
+
+    def find(image_path, tolerance: nil)
+      result = @provider.find(
+        Types::String[image_path],
+        Types::Float.optional[tolerance]
+      )
+
+      if result
+        Success(Point.new(result))
+      else
+        Failure(:not_found)
+      end
+    end
+
+    def find_color(color, tolerance: nil)
+      found = @provider.find_color(
+        Rgba[color],
+        Types::Float.optional[tolerance]
+      )
+
+      if found
+        Success(Point.new(found))
+      else
+        Failure(:not_found)
+      end
+    end
+
+    def all(image_path, tolerance: nil)
+      @provider.all(
+        Types::String[image_path],
+        Types::Float.optional[tolerance]
+      )
+        .map { |point| Point.new(point) }
+    end
+
+    def all_color(color, tolerance: nil)
+      @provider.all_color(
+        Rgba[color],
+        Types::Float.optional[tolerance]
+      )
+        .map { |point| Point.new(point) }
+    end
+
+    def count(image_path, tolerance: nil)
+      @provider.count(
+        Types::String[image_path],
+        Types::Float.optional[tolerance]
+      )
+    end
+  end
+end

data/lib/deskbot/color.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Deskbot
+  class Color < Dry::Struct
+    attribute :red, Types::Integer
+    attribute :green, Types::Integer
+    attribute :blue, Types::Integer
+    attribute :alpha, Types::Integer
+
+    transform_keys do |key|
+      {
+        "r" => :red,
+        "g" => :green,
+        "b" => :blue,
+        "a" => :alpha
+        # rubocop:enable Style/StringHashKeys
+      }.fetch(key, key)
+    end
+
+    def self.from_hex(hex)
+      red, green, blue, alpha = hex
+        .match(/^#(..)(..)(..)(..)?$/)
+        .captures
+        .map do |hex_pair|
+          hex_pair&.hex
+        end
+
+      new(
+        red:,
+        green:,
+        blue:,
+        alpha: alpha || 255
+      )
+    end
+  end
+end

data/lib/deskbot/point.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Deskbot
+  class Point < Dry::Struct
+    attribute :x, Types::Float
+    attribute :y, Types::Float
+
+    transform_keys(&:to_sym)
+  end
+end

data/lib/deskbot/providers/autopilot/bitmap.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Deskbot
+  module Providers
+    module Autopilot
+      class Bitmap # rubocop:disable Lint/EmptyClass
+        # Holds rust autopilot bitmap bindings
+        # See ext/deskbot/src/bitmap.rs for more details
+        #
+        # def bounds
+        # def color_at
+        # def bitmap_eq
+        # def find
+        # def find_color
+        # def all
+        # def all_color
+        # def count
+      end
+    end
+  end
+end

data/lib/deskbot/providers/autopilot.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Deskbot
+  module Providers
+    module Autopilot
+      # Holds rust autopilot bindings
+      # See ext/deskbot/src/lib.rs for more details
+      #
+      # def type
+      # def alert
+      # def toggle_key
+      # def tap_key
+      # def mouse_location
+      # def move_mouse
+      # def smooth_move_mouse
+      # def toggle_mouse
+      # def scroll
+      # def click
+      # def color_at
+      # def screen_size
+      # def screen_scale
+      # def is_point_visible
+      # def is_area_visible
+      # def capture_screen
+      # def capture_screen_portion
+    end
+  end
+end

data/lib/deskbot/screen.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Deskbot
+  class Screen
+    # This is the API for any provider
+
+    def initialize(provider)
+      @provider = provider
+    end
+
+    def alert(message)
+      @provider.alert(Types::String[message])
+    end
+
+    def type(text, flags: [], wpm: 60.0, noise: 0.0)
+      @provider.type(
+        Types::String[text],
+        Types::Flags[flags],
+        Types::Float[wpm],
+        Types::Float[noise]
+      )
+    end
+
+    def toggle_key(key, down: true, flags: [], modifier_delay_ms: 0.0)
+      @provider.toggle_key(
+        Types::Character[key],
+        Types::Bool[down],
+        Types::Flags[flags],
+        Types::Float[modifier_delay_ms]
+      )
+    end
+
+    def tap_key(key, flags: [], delay_ms: 0.0, modifier_delay_ms: 0.0)
+      @provider.tap_key(
+        Types::Character[key],
+        Types::Flags[flags],
+        Types::Float[delay_ms],
+        Types::Float[modifier_delay_ms]
+      )
+    end
+
+    def mouse_location
+      Point.new(@provider.mouse_location)
+    end
+
+    def move_mouse(x, y) # rubocop:disable Naming/MethodParameterName
+      @provider.move_mouse(
+        Types::Coercible::Float[x],
+        Types::Coercible::Float[y]
+      )
+    end
+
+    def smooth_move_mouse(x, y, duration: 1) # rubocop:disable Naming/MethodParameterName
+      @provider.smooth_move_mouse(
+        Types::Coercible::Float[x],
+        Types::Coercible::Float[y],
+        Types::Coercible::Float[duration]
+      )
+    end
+
+    def toggle_mouse(button = "left", down: true)
+      @provider.toggle_mouse(
+        Types::Button[button],
+        Types::Bool[down]
+      )
+    end
+
+    def click(button = "left", delay_ms: nil)
+      @provider.click(
+        Types::Button[button],
+        Types::Float.optional[delay_ms]
+      )
+    end
+
+    def scroll(direction = "up", clicks: 1)
+      @provider.scroll(
+        Types::ScrollDirection[direction],
+        Types::Integer[clicks]
+      )
+    end
+
+    def color_at(x, y) # rubocop:disable Naming/MethodParameterName
+      red, green, blue, alpha = @provider.color_at(
+        Types::Coercible::Float[x],
+        Types::Coercible::Float[y]
+      )
+
+      Color.new(red:, green:, blue:, alpha:)
+    end
+
+    def size
+      Size.new(@provider.screen_size)
+    end
+
+    def scale
+      @provider.screen_scale
+    end
+
+    def point_visible?(x, y) # rubocop:disable Naming/MethodParameterName
+      @provider.is_point_visible(
+        Types::Coercible::Float[x],
+        Types::Coercible::Float[y]
+      )
+    end
+
+    def area_visible?(x:, y:, width:, height:) # rubocop:disable Naming/MethodParameterName
+      @provider.is_area_visible(
+        Types::Coercible::Float[x],
+        Types::Coercible::Float[y],
+        Types::Coercible::Float[width],
+        Types::Coercible::Float[height]
+      )
+    end
+
+    def capture
+      bitmap = @provider.capture_screen
+      Deskbot::Bitmap.new(bitmap)
+    end
+
+    def capture_area(x:, y:, width:, height:) # rubocop:disable Naming/MethodParameterName
+      bitmap = @provider.capture_screen_area(
+        Types::Coercible::Float[x],
+        Types::Coercible::Float[y],
+        Types::Coercible::Float[width],
+        Types::Coercible::Float[height]
+      )
+
+      Deskbot::Bitmap.new(bitmap)
+    end
+  end
+end

data/lib/deskbot/size.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Deskbot
+  class Size < Dry::Struct
+    attribute :width, Types::Float
+    attribute :height, Types::Float
+
+    transform_keys(&:to_sym)
+  end
+end

data/lib/deskbot/types.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Deskbot
+  module Types
+    include Dry.Types(default: :strict)
+
+    Flag = Types::Coercible::String.enum(
+      "shift",
+      "control",
+      "alt",
+      "meta",
+      "help"
+    )
+
+    Button = Types::Coercible::String.enum(
+      "left",
+      "middle",
+      "right"
+    )
+
+    Flags = Types::Array.of(Flag)
+
+    Character = Types::Coercible::String.constrained(size: 1)
+
+    ScrollDirection = Types::Coercible::String.enum(
+      "up",
+      "down"
+    )
+  end
+end

data/lib/deskbot/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Deskbot
+  VERSION = "0.1.0"
+end

data/lib/deskbot.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "dry/types"
+require "dry/struct"
+require "dry/monads"
+require "dry/matcher/result_matcher"
+
+require_relative "deskbot/version"
+require_relative "deskbot/deskbot"
+require_relative "deskbot/types"
+require_relative "deskbot/point"
+require_relative "deskbot/color"
+require_relative "deskbot/size"
+require_relative "deskbot/area"
+require_relative "deskbot/bitmap"
+
+require "deskbot/providers/autopilot/bitmap"
+require "deskbot/providers/autopilot"
+
+require "deskbot/screen"
+
+module Deskbot
+  class Error < StandardError; end
+
+  def self.screen(provider: Providers::Autopilot)
+    @screen ||= Screen.new(provider)
+  end
+end

data/sig/deskbot.rbs

@@ -0,0 +1,4 @@
+module Deskbot
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: deskbot
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nolan J Tait
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-05-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-matcher
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !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'
+- !ruby/object:Gem::Dependency
+  name: dry-monads
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: dry-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+description: Ruby desktop automation
+email:
+- nolanjtait@gmail.com
+executables: []
+extensions:
+- ext/deskbot/Cargo.toml
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Cargo.lock
+- Cargo.toml
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/deskbot/Cargo.toml
+- ext/deskbot/extconf.rb
+- ext/deskbot/src/alert.rs
+- ext/deskbot/src/bitmap.rs
+- ext/deskbot/src/keys.rs
+- ext/deskbot/src/lib.rs
+- ext/deskbot/src/mouse.rs
+- ext/deskbot/src/screen.rs
+- lib/deskbot.rb
+- lib/deskbot/area.rb
+- lib/deskbot/bitmap.rb
+- lib/deskbot/color.rb
+- lib/deskbot/point.rb
+- lib/deskbot/providers/autopilot.rb
+- lib/deskbot/providers/autopilot/bitmap.rb
+- lib/deskbot/screen.rb
+- lib/deskbot/size.rb
+- lib/deskbot/types.rb
+- lib/deskbot/version.rb
+- sig/deskbot.rbs
+homepage: https://github.com/nolantait/desktbot
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/nolantait/desktbot
+  source_code_uri: https://github.com/nolantait/desktbot
+  changelog_uri: https://github.com/nolantait/desktbot
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.11
+requirements: []
+rubygems_version: 3.5.9
+signing_key:
+specification_version: 4
+summary: Ruby dekstop automation
+test_files: []