pads 0.1.0 → 1.0.0

data/lib/pads/mutable_pad_state.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'pads/pad_state'
+
+module Pads
+  # Mutable value object for pad state.
+  class MutablePadState < PadState
+    attr_writer :title, :subtitle, :activity, :clickable, :buttons, :is_drop_target
+
+    def initialize(attrs = {})
+      super()
+      merge! DEFAULTS.merge(attrs)
+    end
+
+    def merge!(attrs)
+      attrs.each do |key, value|
+        __send__ :"#{key}=", value unless __send__(key) == value
+      end
+      self
+    end
+  end
+end

data/lib/pads/observable_pad_state.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'pads/mutable_pad_state'
+require 'observer'
+
+module Pads
+  # A mutable pad state that can be observed.
+  class ObservablePadState < MutablePadState
+    include Observable
+
+    DEFAULTS.each_key do |key|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{key}=(*)        # def title=(*)
+          compare { super }   #   compare { super }
+        end                   # end
+      RUBY
+    end
+
+    def merge!(*)
+      compare { super }
+    end
+
+    private
+
+    def compare
+      return yield if @is_comparing
+
+      @is_comparing = true
+      begin
+        old    = to_h
+        result = yield
+        changed to_h != old
+      ensure
+        @is_comparing = false
+      end
+      notify_observers self
+      result
+    end
+  end
+end

data/lib/pads/pad.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'pads/pad_or_group'
+require 'pads/pad_view'
+require 'observer'
+
+module Pads
+  # Controls a single pad.
+  class Pad
+    include PadOrGroup
+
+    attr_reader :events
+
+    def initialize(attrs = {})
+      @view_stack = []
+      @events     = Events::Dispatcher.new
+
+      push_view PadView.new(attrs)
+
+      yield self if block_given?
+    end
+
+    def view
+      @view_stack.first
+    end
+
+    def push_view(new_view = PadView.new)
+      new_view = PadView[new_view]
+      change_view { @view_stack.unshift new_view }
+      yield new_view if block_given?
+      new_view
+    end
+
+    def pop_view
+      raise 'You cannot pop the top level view' if @view_stack.one?
+
+      change_view { @view_stack.shift }
+    end
+
+    def with_view(new_view = PadView.new)
+      new_view = PadView[new_view]
+      push_view new_view
+      yield new_view
+    ensure
+      pop_view
+    end
+
+    def bind_events(source_dispatcher)
+      @subscriptions = source_dispatcher.publishers.keys.map do |event_name|
+        source_dispatcher.on(event_name) { |*args| view.events.dispatch event_name, *args }
+      end.freeze
+    end
+
+    def unbind_events
+      @subscriptions.each(&:unsubscribe)
+      @subscriptions = nil
+    end
+
+    def view_changed(*)
+      changed
+      notify_observers self
+    end
+
+    private
+
+    def change_view
+      view&.delete_observer self
+      yield
+      view.add_observer self, :view_changed
+      view_changed
+      self
+    end
+
+    def compare
+      old = view
+      result = yield
+      changed old != view
+      notify_observers self
+      result
+    end
+  end
+end

data/lib/pads/pad_group.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'observer'
+require 'pads/pad'
+require 'pads/pad_or_group'
+
+module Pads
+  # Represents a group/sequence of pads.
+  class PadGroup
+    include PadOrGroup
+
+    def initialize(members = [])
+      @members = []
+      @mutex   = Mutex.new
+
+      batch { members.each(&method(:push)) }
+    end
+
+    def insert(index, pad_or_group)
+      raise ArgumentError, 'Index out of range' unless (0..@members.length).cover? index
+
+      pad_or_group        = PadOrGroup.coerce(pad_or_group)
+      pad_or_group.parent = self
+      batch { @members.insert index, pad_or_group }
+    end
+
+    def delete_at(index)
+      batch do
+        @members.delete_at(index).tap { |p| p.parent = nil } or
+          raise ArgumentError, 'Nothing to delete at the given index'
+      end
+    end
+
+    def swap(index_a, index_b)
+      raise ArgumentError, 'Index out of range' unless [index_a, index_b].all?(&(0..@members.length).method(:cover?))
+      raise ArgumentError, 'Indexes are identical' if index_a == index_b
+
+      batch do
+        @members[index_a], @members[index_b] = @members.values_at(index_b, index_a)
+      end
+    end
+
+    def batch
+      return yield if @mutex.owned?
+
+      result = @mutex.synchronize do
+        previous = @members.dup
+        yield.tap do
+          changed previous != @members
+        end
+      end
+      notify_observers self
+      result
+    end
+
+    def push(*args, &block)
+      return push Mapper.map(*args, &block) if block
+
+      batch do
+        args.each do |arg|
+          insert @members.length, arg
+        end
+      end
+    end
+
+    # @return [Array<Pad, PadGroup>]
+    def members
+      @members.dup
+    end
+
+    def relay_notification(*args)
+      changed
+      notify_observers(*args)
+    end
+  end
+end

data/lib/pads/pad_or_group.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Pads
+  # Common functionality for Pads and PadGroups
+  module PadOrGroup
+    include Observable
+
+    def self.coerce(object)
+      case object
+      when Pad, PadGroup
+        object
+      when Hash
+        Pad.new object
+      when Array
+        PadGroup.new object.map(&method(:coerce))
+      when nil
+        PadGroup.new
+      else
+        raise ArgumentError, "Cannot coerce #{object.inspect} to a pad or group of pads"
+      end
+    end
+
+    alias == equal?
+
+    attr_reader :parent
+
+    def parent=(new_parent)
+      return if parent == new_parent
+
+      delete_observer parent if parent
+      @parent = new_parent
+      add_observer parent, :relay_notification if parent
+    end
+  end
+end

data/lib/pads/pad_state.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Pads
+  # Immutable value object for pad state.
+  class PadState
+    DEFAULTS = {
+      title:          '',
+      subtitle:       '',
+      activity:       false,
+      clickable:      false,
+      buttons:        [],
+      is_drop_target: false
+    }.freeze
+
+    attr_reader :title, :subtitle, :activity, :clickable, :buttons, :is_drop_target
+
+    def initialize(attrs = {})
+      DEFAULTS.merge(attrs).each do |key, value|
+        raise ArgumentError, 'Unknown key' unless DEFAULTS.key?(key.to_sym)
+
+        instance_variable_set :"@#{key}", value
+      end
+    end
+
+    def to_h
+      DEFAULTS.keys.to_h do |key|
+        [key, instance_variable_get(:"@#{key}")]
+      end
+    end
+
+    def merge(attrs)
+      self.class.new to_h.merge(attrs)
+    end
+
+    def ==(other)
+      return false unless other.is_a? PadState
+
+      to_h == other.to_h
+    end
+
+    def self.[](obj)
+      obj.is_a?(PadState) ? obj : PadState.new(obj)
+    end
+  end
+end

data/lib/pads/pad_view.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'pads/observable_pad_state'
+
+module Pads
+  # Represents a stackable view of a pad
+  class PadView < ObservablePadState
+    attr_reader :events
+
+    def self.[](obj)
+      obj.is_a?(PadView) ? obj : new(obj)
+    end
+
+    def initialize(attrs = {})
+      super
+
+      @events = Events::Dispatcher.new
+      @button_handlers = []
+
+      @events.on :button_clicked do |event|
+        @button_handlers[event.index]&.call
+      end
+    end
+
+    def on_click(&handler)
+      @events.on :pad_clicked, &handler
+      self.clickable = true
+    end
+
+    def on_drop(path_pattern = nil, &handler)
+      @events.on :files_dropped do |file_dropped|
+        file_dropped.files.each do |file|
+          handler.call(file.path) if path_pattern.nil? || file.path.match?(path_pattern)
+        end
+      end
+      self.is_drop_target = true
+    end
+
+    def button(label, &handler)
+      @button_handlers << handler
+      self.buttons += [label]
+    end
+  end
+end

data/lib/pads/provider/group_binding.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pads
+  class Provider
+    # Represents a server binding for a pad group. Just an array, but uses object IDs for comparisons, so that e.g.
+    # two empty groups are not considered equal.
+    class GroupBinding < Array
+      alias == equal?
+    end
+  end
+end

data/lib/pads/provider/tracking.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'pads/provider/group_binding'
+
+module Pads
+  class Provider
+    # Supplemental methods for the Provider class
+    module Tracking
+      protected
+
+      def pad?(pad_or_group)
+        case pad_or_group
+        when Pad, Client::Pad
+          true
+        when PadOrGroup, GroupBinding
+          false
+        else
+          raise ArgumentError, 'Expected a pad or group'
+        end
+      end
+
+      def pad_range_for_binding(binding)
+        return [binding, binding] if pad? binding
+
+        flat = binding.flatten
+        flat.empty? ? nil : [flat.first, flat.last]
+      end
+
+      def subtract_pad_range(partial_group_binding, range_to_remove)
+        indexes_to_remove = range_to_remove.map(&partial_group_binding.method(:index))
+        remaining = partial_group_binding[
+          indexes_to_remove.first.zero? ? (indexes_to_remove.last + 1).. : 0...indexes_to_remove.first
+        ].flatten
+        remaining.empty? ? nil : [remaining.first, remaining.last]
+      end
+
+      def walk(pad_group_binding, skip_group_bindings: true, &block)
+        yield pad_group_binding unless skip_group_bindings
+
+        pad_group_binding.each do |binding|
+          if pad? binding
+            block.call binding
+          else
+            walk binding, skip_group_bindings: skip_group_bindings, &block
+          end
+        end
+
+        yield nil unless skip_group_bindings
+      end
+
+      def create_options(root_binding, pad_group_binding) # rubocop:disable Metrics/MethodLength
+        create_options = {}
+        phase          = 1 # 1 = before this group, 2 = in this group, 3 = after this group
+
+        walk root_binding, skip_group_bindings: false do |binding|
+          if binding == pad_group_binding
+            break if create_options[:after]
+
+            phase = 2
+          elsif binding.nil?
+            phase = 3
+          elsif binding.is_a? GroupBinding
+            next
+          elsif phase == 1
+            create_options[:after] = binding
+          elsif phase == 3
+            create_options[:before] = binding
+            break
+          end
+        end
+
+        create_options
+      end
+    end
+  end
+end

data/lib/pads/provider.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'pads/client'
+require 'pads/pad_group'
+require 'pads/provider/tracking'
+
+module Pads
+  # The base class for a long-running process that provides pads to the Pads app.
+  class Provider
+    include Tracking
+
+    def initialize(client = Client.new)
+      @client = client
+      @root   = PadGroup.new
+      @mutex  = Mutex.new
+
+      @bindings         = { @root => GroupBinding.new }.compare_by_identity
+      @bindings_inverse = @bindings.invert.compare_by_identity
+
+      @root.add_observer self, :pad_or_group_update
+    end
+
+    def push(*args, &block)
+      @root.push(*args, &block)
+    end
+
+    def wait
+      @client.wait
+    end
+
+    def pad_or_group_update(pad_or_group)
+      return @mutex.synchronize { pad_or_group_update pad_or_group } unless @mutex.owned?
+
+      if pad? pad_or_group
+        pad_update pad_or_group
+      else
+        pad_group_update pad_or_group
+      end
+    end
+
+    private
+
+    # @param [Pads::Pad] pad
+    def pad_update(pad)
+      binding_for(pad).merge! pad.view.to_h
+    end
+
+    def pad_group_update(pad_group)
+      pad_group_binding = binding_for(pad_group)
+      remove_old_members pad_group, pad_group_binding
+      sort_members pad_group, pad_group_binding
+      add_new_members pad_group, pad_group_binding
+    end
+
+    def remove_old_members(pad_group, pad_group_binding)
+      expected = Set.new(pad_group.members)
+      pad_group_binding.each.with_index.reverse_each do |member_binding, index|
+        member = pad_or_group_for(member_binding)
+        next if expected.include? member
+
+        destroy member
+        pad_group_binding.delete_at index
+      end
+    end
+
+    def sort_members(pad_group, pad_group_binding)
+      return unless pad_group_binding.length > 1
+
+      expected = pad_group.members.map(&@bindings.method(:[])) & pad_group_binding
+
+      (0..(pad_group_binding.length - 2)).each do |i|
+        a = expected[i]
+        b = pad_group_binding[i]
+
+        swap pad_group_binding, i, pad_group_binding.index(a) unless b == a
+      end
+    end
+
+    def add_new_members(pad_group, pad_group_binding)
+      create_options = self.create_options(binding_for(@root), pad_group_binding)
+
+      pad_group.members.each.with_index do |member, index|
+        binding = @bindings[member] ||
+                  create_binding(member, create_options).tap { |b| pad_group_binding.insert index, b }
+
+        create_options = { after: binding } if binding.is_a? Client::Pad
+      end
+    end
+
+    def create_binding(member, create_options)
+      is_pad = pad?(member)
+      binding = is_pad ? @client.create_pad(**create_options) : GroupBinding.new
+
+      @bindings[member]          = binding
+      @bindings_inverse[binding] = member
+
+      member.bind_events(binding.events) if is_pad
+
+      pad_or_group_update(member)
+
+      binding
+    end
+
+    def swap(pad_group_binding, index_a, index_b) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      bindings = [index_a, index_b].map(&pad_group_binding.method(:fetch))
+
+      pad_group_binding[index_b], pad_group_binding[index_a] = bindings
+
+      ranges = bindings.map(&method(:pad_range_for_binding)).sort_by { |range| range.nil? ? 1 : 0 }
+      return if ranges.all?(&:nil?)
+
+      ranges[1] ||= subtract_pad_range(pad_group_binding[index_a..index_b], ranges[0])
+      return if ranges[1].nil?
+
+      @client.swap_pads(*ranges)
+    end
+
+    def binding_for(pad_or_group)
+      @bindings.fetch(pad_or_group) { raise "No server binding for #{pad_or_group}" }
+    end
+
+    def pad_or_group_for(binding)
+      @bindings_inverse.fetch(binding)
+    end
+
+    def destroy(pad_or_group)
+      binding = binding_for(pad_or_group)
+
+      if pad? pad_or_group
+        pad_or_group.unbind_events
+        binding.destroy
+      else
+        binding.each(&method(:destroy))
+      end
+
+      @bindings.delete pad_or_group
+      @bindings_inverse.delete binding
+    end
+  end
+end

data/lib/pads/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pads
-  VERSION = "0.1.0"
+  VERSION = '1.0.0'
 end

data/lib/pads.rb

@@ -1,8 +1,19 @@
 # frozen_string_literal: true
 
-require_relative "pads/version"
+require 'pads/version'
+require 'pads/provider'
+require 'pads/mapper'
+require 'pads/live_array'
 
+# Provide pads to the Pads macOS app.
 module Pads
-  class Error < StandardError; end
-  # Your code goes here...
+  def self.provide(*args)
+    provider = Provider.new(*args)
+    yield provider
+    provider.wait
+  end
+
+  def self.pad(*args, &block)
+    Pad.new *args, &block
+  end
 end

data/pads.gemspec

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
-require_relative "lib/pads/version"
+require_relative 'lib/pads/version'
 
 Gem::Specification.new do |spec|
-  spec.name = "pads"
+  spec.name = 'pads'
   spec.version = Pads::VERSION
-  spec.authors = ["Neil E. Pearson"]
-  spec.email = ["neil@pearson.sydney"]
+  spec.authors = ['Neil E. Pearson']
+  spec.email = ['neil@pearson.sydney']
 
-  spec.summary = "Ruby client for the Pads macOS app"
-  spec.description = "Ruby client for the Pads macOS app"
-  spec.homepage = "https://github.com/hx/pads"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.6.0"
+  spec.summary = 'Ruby client for the Pads macOS app'
+  spec.description = 'Ruby client for the Pads macOS app'
+  spec.homepage = 'https://github.com/hx/pads'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 2.6.3'
 
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
@@ -24,13 +24,15 @@ Gem::Specification.new do |spec|
       (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
     end
   end
-  spec.bindir = "exe"
+  spec.bindir = 'exe'
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
   # Uncomment to register a new dependency of your gem
   # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_dependency 'interop', '~> 0.3.1'
 
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html
+  spec.metadata['rubygems_mfa_required'] = 'true'
 end