appear 1.1.1 → 1.2.0

data/lib/appear/util/join.rb

@@ -0,0 +1,144 @@
+module Appear
+  module Util
+    # Class for joining objects based on hash value or method value.
+    # @see Join.join
+    class Join
+      # Join objects or hashes together where thier field values match. This
+      # method is analogous to a JOIN in SQL, althought the behavior is not
+      # exactly the same.
+      #
+      # @example
+      #   foos = many_foos
+      #   bars = many_bars
+      #   foo_bars = Join.join(:common_attribute, foos, bars)
+      #
+      #   # can still access all the properties on either a foo or a bar
+      #   foo_bars.first.common_attribute
+      #
+      #   # can access attributes by symbol, too
+      #   foo_bars.first[:something_else]
+      #
+      # foo_bars is an array of Join instances. Reads from a foo_bar will read
+      # first from the foo, and then from the bar - this is based on the order of
+      # "tables" passed to Join.join().
+      #
+      # @param field [Symbol] the method or hash field name to join on.
+      # @param tables [Array<Any>] arrays of any sort of object, so long as it is
+      #   either a hash, or has a method named `field`.
+      # @return [Array<Join>]
+      def self.join(field, *tables)
+        by_field = Hash.new { |h, k| h[k] = self.new }
+
+        tables.each do |table|
+          table.each do |row|
+            field_value = access(row, field)
+            joined = by_field[field_value]
+            joined.push!(row)
+          end
+        end
+
+        by_field.values.select do |joined|
+          joined.joined_count >= tables.length
+        end
+      end
+
+      # True if we can access the given field on an object, either by calling
+      # that method on the object, or by accessing using []
+      #
+      # @param obj [Any]
+      # @param field [Symbol, String]
+      # @return [Boolean]
+      def self.can_access?(obj, field)
+        if obj.respond_to?(field)
+          return true
+        elsif obj.respond_to?(:[])
+          return true
+        end
+        return false
+      end
+
+      # Access the given field on an object.
+      # Raises an error if the field cannot be accessed.
+      #
+      # @param obj [Any]
+      # @param field [Symbol, String]
+      # @return [Any] the value at that field
+      def self.access(obj, field)
+        if obj.respond_to?(field)
+          obj.send(field)
+        elsif obj.respond_to?(:[])
+          obj[field]
+        else
+          raise "cannot access #{field.inspect} on #{obj.inspect}"
+        end
+      end
+
+      # A Join is a union of data objects. You can use a Join to group objects of
+      # different types, so that you may read from whichever has a given field.
+      #
+      # It is more useful to use self.join to perform a join operation on
+      # collections than to create Join objects directly.
+      def initialize(*objs)
+        @objs = objs
+      end
+
+      # add another data object to this join.
+      #
+      # @param obj [Any]
+      def push!(obj)
+        @objs << obj
+      end
+
+      # get the number of objects in this join
+      #
+      # @return [Fixnum]
+      def joined_count
+        @objs.length
+      end
+
+      # Return the first member in the join that matches the given block.
+      # @yield [Object] join member.
+      def unjoin(&block)
+        @objs.find(&block)
+      end
+
+      # read a field from the join. Returns the first non-nil value we can read.
+      # @see self.access for information about how fields are accessed.
+      #
+      # @param sym [String, Symbol] the field name
+      # @return [Any, nil]
+      def [](sym)
+        result = nil
+
+        @objs.each do |obj|
+          if self.class.can_access?(obj, sym)
+            result = self.class.access(obj, sym)
+          end
+          break unless result.nil?
+        end
+
+        result
+      end
+
+      # the {#method_missing} implementation on a Join allows you to access valid
+      # fields with regular accessors.
+      #
+      # @param method [String, Symbol]
+      # @param args [Array<Any>] should have none
+      # @param block [Proc] should have none
+      def method_missing(method, *args, &block)
+        raise NoMethodError.new("Cannot access #{method.inspect}") unless respond_to?(method)
+        raise ArgumentError.new("Passed args to accessor") if args.length > 0
+        raise ArgumentError.new("Passed block to accessor") if block
+        self[method]
+      end
+
+      # @param sym [String, Symbol] name of the method
+      # @param priv [Boolean] default false
+      # @return [Boolean] true if we can respond to the given method name
+      def respond_to?(sym, priv = false)
+        super(sym, priv) || (@objs.any? { |o| self.class.can_access?(o, sym) })
+      end
+    end
+  end
+end

data/lib/appear/util/memoizer.rb

@@ -0,0 +1,83 @@
+require 'thread'
+
+module Appear
+  module Util
+    # A Memoizer memoizes calls to a block, skipping repeated work when the
+    # arguments are the same. Memoization is thread-safe, so it's safe to
+    # memoize pure computations that occur on different threads.
+    #
+    # @example memoize a method
+    #   class Example
+    #     def initialize
+    #       @memo = Memoizer.new
+    #     end
+    #
+    #     def foo(a, b)
+    #       @memo.call(a, b) do
+    #         expensive_computaion(a, b)
+    #       end
+    #     end
+    #   end
+    #
+    # @example memoize part of a computation
+    #   class Example
+    #     def initialize
+    #       @memo = Memoizer.new
+    #     end
+    #
+    #     def foo(a, b)
+    #       state = get_state(a, b)
+    #       d = memo.call(state) { expensive_pure_computation(state) }
+    #       [a, d]
+    #     end
+    #   end
+    class Memoizer
+      def initialize
+        @cache = {}
+        @cache_mutex = Mutex.new
+        @disable = false
+      end
+
+      # Memoize the call to a block. Any arguments given to this method will be
+      # passed to the given block.
+      #
+      # @param args [Array<Any>] memoization key
+      # @return [Any] result of the block
+      def call(*args)
+        raise ArgumentError.new('no block given') unless block_given?
+
+        if @disable
+          return yield
+        end
+
+        @cache_mutex.synchronize do
+          return @cache[args] if @cache.key?(args)
+        end
+
+        result = yield
+        @cache_mutex.synchronize do
+          @cache[args] = result
+        end
+        result
+      end
+
+      # Evict the cache
+      #
+      # @return [self]
+      def clear!
+        @cache_mutex.synchronize do
+          @cache = {}
+        end
+        self
+      end
+
+      # Disable memoization permanently on this instance.
+      #
+      # @return [self]
+      def disable!
+        @disable = true
+        self
+      end
+    end
+  end
+end

data/lib/appear/util/value_class.rb

@@ -0,0 +1,57 @@
+require 'appear/constants'
+
+module Appear
+  module Util
+
+    # An immutable value type, similar to Struct, but with annotated
+    # attr_readers, that can be easily created from a Hash with the necessary
+    # fields.
+    class ValueClass
+      # Thrown if a value is not supplied for an attribute
+      class MissingValueError < ::Appear::Error; end
+
+      # @param data [Hash]
+      def initialize(data)
+        self.class.properties.each do |val|
+          begin
+            instance_variable_set("@#{val}", data.fetch(val))
+          rescue KeyError
+            raise MissingValueError.new("#{self.class.name}: no value for attribute #{val.inspect}")
+          end
+        end
+      end
+
+      # Define an attribute reader that can be populated by the constructor.
+      #
+      # @param name [Symbol] define an attr_reader with this name
+      # @param opts [Hash] options
+      # @option opts [Symbol] :var instance variable we should read from
+      #
+      # @!macro [attach] value_class_property
+      #   @!method $1
+      #   The $1 property.
+      def self.property(name, opts = {})
+        var_name = opts.fetch(:var, name)
+
+        @props ||= []
+        @props << var_name
+
+        # we could do super, but we want to allow defining :acttive? or so
+        class_eval "def #{name}; @#{var_name}; end"
+
+        var_name
+      end
+
+      # @return [Array<Symbol>] names of all properties
+      def self.properties
+        @props ||= []
+        if self.superclass.respond_to?(:properties)
+          self.superclass.properties + @props
+        else
+          @props
+        end
+      end
+    end
+
+  end
+end

data/lib/appear/util.rb

@@ -0,0 +1,6 @@
+module Appear
+  # This module stores non-service classes that have no relation to Appear's
+  # business domain.
+  module Util
+  end
+end

data/lib/appear.rb

@@ -1,6 +1,23 @@
+# Appear your terminal programs in your gui!
+#
+# Appear is a tool for revealing a given process in your terminal. Given a
+# process ID, `appear` finds the terminal emulator view (be it a window, tab,
+# or pane) containing that process and shows it to you. Appear understands
+# terminal multiplexers like `tmux`, so if your target process is in a
+# multiplexer session, `appear` will reveal a client connected to that session,
+# or start one if needed.
+#
+# Most users of this library will find the {Appear.appear} method sufficient,
+# although you may construct and control library internals using the
+# {Appear::Instance} class, which is our "main" class.
+#
+# Other useful ideas include the {Appear::BaseService} class, which is a
+# super-simple dependency-injection base class.
+#
+# @author Jake Teton-Landis <just.1.jake@gmail.com>
 module Appear
-  # This method is an easy public interface to Appear for ruby consumers.
   # Appear the given PID in your user interfaces.
+  # This method is an easy public interface to Appear for ruby consumers.
   # @param pid [Number] pid to Appear.
   # @param config [Appear::Config, nil] a config for adjusting verbosity and logging.
   def self.appear(pid, config = nil)
@@ -8,7 +25,44 @@ module Appear
     instance = Appear::Instance.new(config)
     instance.call(pid)
   end
+
+  # Build a command string that will execute `appear` with the given config and
+  # arguments. If `appear` is in your PATH, we will use that binary. Otherwise,
+  # we will call the script in ./bin/ folder near this library, which has a
+  # #!/usr/bin/env ruby shbang.
+  #
+  # You may optionally need to prepend "PATH=#{ENV['PATH']} " to the command if
+  # `tmux` is not in your command execution environment's PATH.
+  #
+  # Intended for use with the terminal-notifier gem.
+  # @see https://github.com/julienXX/terminal-notifier/tree/master/Ruby
+  #
+  # @example Show a notification that will raise your program
+  #   require 'appear'
+  #   require 'terminal-notifier'
+  #   TerminalNotifier.notify('Click to appear!', :execute => Appear.build_command(Process.pid))
+  #
+  # @param pid [Number] pid to Appear.
+  # @param config [Appear::Config, nil] a config for adjusting verbosity and logging.
+  # @return [String] a shell command that will execute `appear`
+  def self.build_command(pid, config = nil)
+    binary = `which appear`.strip
+    if binary.empty?
+      binary = Appear::MODULE_DIR.join('bin/appear').to_s
+    end
+
+    command = Appear::Util::CommandBuilder.new(binary).args(pid)
+
+    if config
+      command.flag('verbose', true) unless config.silent
+      command.flag('log-file', config.log_file) if config.log_file
+      command.flag('record-runs', true) if config.record_runs
+    end
+
+    command.to_s
+  end
 end
 
 require 'appear/config'
 require 'appear/instance'
+require 'appear/util/command_builder'

data/scripts/console

@@ -7,6 +7,7 @@
 require "bundler/setup"
 require "pry"
 require "appear"
+require "appear/editor"
 
 def create_appear_instance
   config = Appear::Config.new
@@ -16,6 +17,13 @@ def create_appear_instance
 end
 
 instance, config = create_appear_instance
-puts "generated instance #{instance} from config #{config}"
+services = instance.instance_variable_get('@all_services')
+# nvim = Appear::Editor::Nvim.find_for_file(File.expand_path('.'))
+# nvim = Appear::Editor::Nvim.new(Appear::Editor::Nvim.sockets.last, services)
+nvim = Appear::Editor::Nvim.find_for_file(__FILE__, services)
+ide = Appear::Editor::TmuxIde.new(services)
+puts "generated instance = #{instance} from config = #{config}"
+puts "connected nvim = #{nvim}"
+puts "generated ide = #{ide}"
 
 binding.pry

data/tools/macOS-helper.js

@@ -27,6 +27,15 @@ var ScriptContext = this
 // -----------------------------------------------------------
 var PROGRAM_NAME = 'appear-macOS-helper'
 var Methods = {}
+function delegateMethod(methodName, klass, fn) {
+  result = function() {
+    var instance = new klass();
+    return instance[fn].apply(instance, arguments)
+  }
+  result.name = methodName
+  Methods[methodName] = result
+  return result
+}
 
 // entrypoint -------------------------------------------------
 // this is the main method of this script when it is called from the command line.
@@ -121,16 +130,22 @@ Iterm2.prototype.revealTty = function revealTty(tty) {
   return success;
 }
 
-Methods['iterm2_reveal_tty'] = function iterm2_reveal_tty(tty) {
-  var iterm2 = new Iterm2()
-  return iterm2.revealTty(tty)
-}
+Iterm2.prototype.newWindow = function newWindow(command) {
+  var window = this.app.createWindowWithDefaultProfile({command: command})
+  var session = window.currentSession();
 
-Methods['iterm2_panes'] = function iterm2_panes() {
-  var iterm2 = new Iterm2()
-  return iterm2.panes()
+  return {
+    win: window,
+    tab: window.currentTab(),
+    session: session,
+    tty: session.tty(),
+  };
 }
 
+delegateMethod('iterm2_reveal_tty', Iterm2, 'revealTty')
+delegateMethod('iterm2_panes', Iterm2, 'panes')
+delegateMethod('iterm2_new_window', Iterm2, 'newWindow')
+
 // -------------------------------------------------------------
 // Terminal.app library
 
@@ -168,15 +183,8 @@ Terminal.prototype.revealTty = function revealTty(tty) {
   return success
 }
 
-Methods['terminal_reveal_tty'] = function terminal_reveal_tty(tty) {
-  var terminal = new Terminal()
-  return terminal.revealTty(tty)
-}
-
-Methods['terminal_panes'] = function terminal_panes() {
-  var terminal = new Terminal()
-  return terminal.panes()
-}
+delegateMethod('terminal_reveal_tty', Terminal, 'revealTty')
+delegateMethod('terminal_panes', Terminal, 'panes')
 
 // for tests ----------------------------------------------
 

data/tools/unix-dropper.applescript

@@ -0,0 +1,167 @@
+#!/usr/bin/env osascript
+(*
+ * script: unix-dropper.applescript
+ * author: Jake Teton-Landis <just.1.jake@gmail.com>
+ * date:   2016-08-30
+ *
+ * when saved as an application (open in Script Editor, then choose
+ * File->Export...), this script can be used to process files or folders with a
+ * Unix script via drag-and-drop.
+ *
+ * You can customize the preferences of your Unix script by opening the
+ * application the regular way.
+ *
+ * Your script will be called as a sh function, so you can process $@ using
+ * `shift` or something.
+ *
+ * Heplful documentation for maintainers:
+ *   Technical Note TN2065 - do shell script in AppleScript
+ *   https://developer.apple.com/library/mac/technotes/tn2065/_index.html
+ *
+ * Here's the default script that this app will run, creaetd from the default
+ * property `user_unix_command`, defined below, as though the dropped files were
+ * "first", "second", "third".
+ *
+ * ```sh
+ * #!/bin/sh
+ * script-wrapper () {
+ * ARG_C='3'
+ * ARG_1='first'
+ * ARG_2='second'
+ * ARG_3='third'
+ * say "dropped $ARG_C files. first file: $ARG_0"
+ * }
+ * # we do this so you can use "$@"
+ * # and unix conventions if you're unix-y
+ * script-wrapper first second third
+ * ```
+ *)
+
+-- property default_command : "say \"dropped $ARG_C files. first file: $ARG_0\""
+property default_command : "PATH=\"/usr/local/bin:$PATH\" /usr/local/bin/appear --edit -- \"$@\""
+
+
+--- this is a stored user preference.
+--- this is the default, but it can be set as a preference in a .plist if this script is saved as an applicication
+property user_unix_command : default_command
+
+--- this function runs when the user opens the application by double-clicking it.
+--- uer can adjust the user_unix_command by opening the application
+on run
+	set quit_ to "Quit"
+	set reset to "Reset"
+	set save_ to "Save"
+	repeat
+		set ds to doc_string()
+		set d_res to display dialog ds buttons {quit_, reset, save_} default button save_ default answer user_unix_command
+		if the button returned of d_res is save_ then
+			set user_unix_command to the text returned of the result
+		end if
+		if the button returned of d_res is quit_ then
+			return "user quit"
+		end if
+	end repeat
+end run
+
+-- This droplet processes files dropped onto the applet
+on open these_items
+	set as_strings to {}
+	repeat with cur in these_items
+		set cur_as_string to (POSIX path of cur) as string
+		copy cur_as_string to end of as_strings
+	end repeat
+	set the_command to unix_script(user_unix_command, as_strings)
+	log the_command
+	do shell script the_command
+end open
+
+--- here's how we end up building the shell script to call
+--- the user's shell script with hella sweet args
+on build_arg_vars(args)
+	-- MOAR SPEED
+	return {}
+	set argc to the count of args
+	set res to {set_env_var("ARG_C", argc)}
+	
+	repeat with i from 1 to the count of args
+		set arg to item i of args
+		copy set_env_var("ARG_" & i, arg) to end of res
+	end repeat
+	res
+end build_arg_vars
+
+on build_script(user_script, args)
+	set fn_name to "wrapper_fn"
+	set open_fn to fn_name & " () {"
+	set close_fn to "}"
+	set call_fn to fn_name & " " & join_list(args, " ")
+	set comment to "# we do this so you can use \"$@\"
+# and unix conventions if you're unix-y"
+	
+	set res to build_arg_vars(args)
+	
+	copy open_fn to beginning of res
+	copy user_script to end of res
+	copy close_fn to end of res
+	copy comment to end of res
+	copy call_fn to end of res
+	res
+end build_script
+
+on set_env_var(var, value)
+	
+	set res to var & "=" & (the quoted form of ("" & value))
+	# display dialog res
+	
+	return res
+	
+end set_env_var
+
+on join_list(the_list, sep)
+	if (count of the_list) is 0 then
+		return ""
+	end if
+	
+	if (count of the_list) is 1 then
+		return "" & item 1 of the_list
+	end if
+	
+	set res to "" & item 1 of the_list
+	
+	repeat with i from 2 to the count of the_list
+		set el to item i of the_list
+		set res to res & sep & el
+	end repeat
+	res
+end join_list
+
+on unix_script(user_command, args)
+	join_list(build_script(user_command, args), "
+")
+end unix_script
+
+
+-- returns string
+on doc_string()
+	"Enter a unix command to run when this application should open a file. Your script has several environment variables availible, see below.
+
+Substitutions availible:
+\"$@\":  All arguments, quoted
+(all sh default environment variables)
+$ARG_C:  Total number of arguments
+$ARG_1:  First argument
+$ARG_2:  Second argument
+etc...
+
+Current command:
+`" & user_unix_command & "`
+
+Final script, given dropped files {first, second, third}:
+```sh
+#!/bin/sh
+" & unix_script(user_unix_command, {"first", "second", "third"}) & "
+```"
+end doc_string
+
+--- uncomment to test
+-- unix_script("/Users/jake/src/foo $1 a/b $ARG_4 -- \"$@\"", {"foo", "bar"})

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: appear
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Jake Teton-Landis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-10 00:00:00.000000000 Z
+date: 2016-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -114,8 +114,9 @@ files:
 - lib/appear/command.rb
 - lib/appear/config.rb
 - lib/appear/constants.rb
+- lib/appear/editor.rb
+- lib/appear/editor/nvim.rb
 - lib/appear/instance.rb
-- lib/appear/join.rb
 - lib/appear/lsof.rb
 - lib/appear/mac_os.rb
 - lib/appear/output.rb
@@ -123,11 +124,18 @@ files:
 - lib/appear/revealers.rb
 - lib/appear/runner.rb
 - lib/appear/service.rb
+- lib/appear/terminal.rb
 - lib/appear/tmux.rb
+- lib/appear/util.rb
+- lib/appear/util/command_builder.rb
+- lib/appear/util/join.rb
+- lib/appear/util/memoizer.rb
+- lib/appear/util/value_class.rb
 - screenshot.gif
 - scripts/console
 - scripts/setup
 - tools/macOS-helper.js
+- tools/unix-dropper.applescript
 homepage: https://github.com/airbnb/appear
 licenses: []
 metadata: {}