xiki 0.5.0a

data/lib/pause_means_space.rb

@@ -0,0 +1,68 @@
+require 'keys'
+
+class PauseMeansSpace
+
+  def self.go
+    Cursor.remember :before_q
+    Cursor.green
+
+    while(inserted = insert_until_pause)
+      next if inserted == 127
+      if inserted == "."
+        $el.delete_backward_char 2;  insert ".  "
+        next
+
+      end
+      insert " "
+    end
+    $el.delete_backward_char 1
+    $el.message "Typing finished"
+
+    Cursor.restore :before_q
+    # TODO print ---- if enter
+  end
+
+  def self.insert_until_pause
+    # Get first char and insert
+    c = $el.read_char("insert text (pause means space): ")
+
+    # Exit if they pressed enter
+    return false if c == 13
+
+    # Delete if they pressed delete
+    if c == 127
+      $el.backward_kill_word 1
+      return 127
+    end
+
+    inserted = "#{c.chr}"
+    insert c.chr
+
+    o = $el.make_overlay $el.point, $el.point - 1
+
+    # TODO use different face - purple?
+
+    $el.overlay_put o, :face, :control_lock_found
+    # While no pause, insert more chars
+    while(c = read_char("insert text (pause means space): ", nil, 0.24))
+      $el.delete_overlay o
+
+      # Exit if they pressed enter
+      return false if c == 13
+      inserted += c.chr
+      insert c.chr
+
+      o = $el.make_overlay $el.point, $el.point - inserted.size
+      $el.overlay_put o, :face, :control_lock_found
+    end
+    $el.delete_overlay o
+
+    # User didn't press enter
+    return inserted
+
+  end
+  def self.keys
+    Keys.set("C-S-q", "PauseMeansSpace.go")
+  end
+
+end

data/lib/php.rb

@@ -0,0 +1,22 @@
+class Php
+  def self.run
+    # Get block contents
+    txt, left, right = View.txt_per_prefix #:prefix=>Keys.prefix
+
+    result = self.run_internal txt
+    # Insert result at end of block
+    orig = Location.new
+    View.cursor = right
+    Line.to_left
+    View.insert result.gsub(/^/, '  ')+"\n"
+    orig.go
+  end
+
+  def self.run_internal txt
+    # Write to temp file
+    File.open("/tmp/tmp.php", "w") { |f| f << "<?\n#{txt}\n?>\n" }
+    # Call js
+    Console.run "php -f /tmp/tmp.php", :sync=>true
+  end
+
+end

data/lib/projects.rb

@@ -0,0 +1,21 @@
+class Projects
+  def self.menu
+    "
+    - This will never be called, because of projects.menu...
+      - Think again of ways for .menu and .rb to work together creating menus
+    - api/
+    "
+  end
+
+  def self.current
+    # If parent is dir, return it, else return first project
+    dir = FileTree.handles?(Xiki.trunk[-2]) ? "#{Dir.pwd}/" : self.default_project
+  end
+
+  def self.default_project
+    txt = File.read(File.expand_path "~/menus/projects.menu") rescue nil
+    return nil if ! txt
+
+    Line.without_label(:line=>txt[/.+/])
+  end
+end

data/lib/relinquish_exception.rb

@@ -0,0 +1,2 @@
+class RelinquishException < RuntimeError
+end

data/lib/remote.rb

@@ -0,0 +1,206 @@
+gem 'net-ssh'
+require 'net/ssh'
+require 'net/sftp'
+require 'timeout'
+require 'ol'
+
+class Remote
+
+  @@temp_dir = "/tmp/remote_rb"
+
+  @@connections = {}
+
+  def self.menu
+    "
+    - docs/
+      > Summary
+      | You can browse files and run commands on remote servers.
+      @ /user@foo.com/tmp/
+    << see) @servers/
+    "
+  end
+
+  # Called when dir or file is launched
+  def self.file_contents whole_path
+    user, server, port, path = self.split_root(whole_path)
+    connection = self.connection whole_path
+    connection.sftp.download!(path)
+  end
+
+  def self.dir root, *path_append
+
+    connection = self.connection root
+
+    user, server, port, path = self.split_root(root)
+
+    # Add slash to path if none there
+    path << "/" unless path =~ /\/$/
+
+    path_passed = path_append.size > 0
+
+    if path_passed  # If anything in array
+      path << "#{path_append.join('')}"  # append to path
+      path.sub! /^\/\//, '/'
+    end
+
+    timeout(15) do
+      if path =~ /\/$/   # If a dir
+        out = connection.exec!("ls -pa #{path}")
+        out ||= ""
+        out = out.grep(/^[^#]+$/).join("")   # Weed out #...#
+        out.gsub!(/@/, '/')   # Change @ to /
+
+        # Get rid of . and ..
+        out = out.split("\n").select{|o| o !~ /^\.+\/$/}.join("\n")+"\n"
+        self.sort(out)
+
+      else   # If a file
+
+        Dir.mkdir @@temp_dir unless File.exists? @@temp_dir
+        local_path = self.calculate_local_path path, server
+
+        was_open = Files.open? local_path
+
+        # Download if not open already
+        unless was_open
+          begin
+            connection.sftp.download!(path, local_path)
+          rescue Exception=>e
+            # If doesn't exist, we'll just create
+          end
+        end
+
+        View.to_after_bar
+        View.open local_path
+
+        # TODO: save root path as var in buffer
+        $el.make_local_variable :remote_rb_server_root
+        server_root = "/#{user}@#{server}#{port ? ":#{port}" : ""}/"
+        $el.elvar.remote_rb_server_root = server_root
+
+        # TODO save timestamp in buffer var
+        # - Use it to determine whether file changed when saving
+
+      end
+    end
+  end
+
+  def self.command root #, *path_append
+
+    the_command = root[-1][/\$ ?(.+)/, 1]
+
+    # Pull off command
+    while(root.last =~ /^\$/) do   # Remove all !foo lines from root
+      root.pop
+    end
+    root = root.join('')
+
+    connection = self.connection root
+
+    user, server, port, path = self.split_root(root)
+
+    path << "/" unless path =~ /\/$/   # Add slash to path if none there
+
+    timeout(6) do
+      out = connection.exec!("cd \"#{path}\" && #{the_command}")
+      #       out = connection.exec!("cd \"#{path}\"; #{the_command}")
+      out ||= ""
+
+      Tree.under out, :escape=>'| ', :no_slash=>1
+    end
+  end
+
+  def self.connections
+    @@connections
+  end
+
+  def self.connection root
+    user, server, port, path = self.split_root root
+    address = "#{user}@#{server}:#{port}"
+    @@connections[address] ||= self.new_connection user, server, port.to_i
+    @@connections[address]
+  end
+
+  def self.new_connection user, server, port
+    begin
+      timeout(6) do
+        Net::SSH.start(server, user, :port => port.to_i, :paranoid => false)
+      end
+    rescue Exception => e
+      raise "Timed out: #{e.message}"
+    end
+  end
+
+
+  def self.split_root root   # Splits name@server:port/path
+    root = root.dup   # Append / at end if no / exists
+    root << "/" unless root =~ /\/$/
+
+    user, server_port, path = root.match(/^(.+?)@(.+?)(\/.*?)\/?$/)[1..3]
+
+    if(server_port =~ /(.+?):(.+)/)
+      server, port = $1, $2
+    else
+      server, port = server_port, "22"
+    end
+
+    user.sub! /^\//, ''
+    [user, server, port, path]
+  end
+
+  def self.sort lines
+    l = lines.split("\n")
+    l.sort!{|a,b| a.sub(/(.+)\//, "\\1") <=> b.sub(/(.+)\//, "\\1")}
+  end
+
+  def self.remote_buffer_name(server, path)
+    dir, file = path.match(/(.+\/)(.+)/)[1..2]
+    "*remote #{file} (#{server}:#{dir})"
+  end
+
+  def self.save_file
+    local_path = View.file
+    # Error out if not in right place
+    if local_path !~ /^#{@@temp_dir}/
+      View.beep
+      return View.message("This isn't a file the Remote code_tree retrieved")
+    end
+
+    # Save if modified
+    $el.save_buffer if $el.buffer_modified_p
+
+    remote_path = $el.elvar.remote_rb_server_root
+
+
+    # Convert to path
+    remote_path = self.calculate_remote_path local_path
+    begin   # Do save
+      connection = self.connection $el.elvar.remote_rb_server_root
+      connection.sftp.upload!(local_path, remote_path)
+      View.message "successfully saved remotely!"
+    rescue Exception => e
+      View.message "- error: #{e.message}"
+    end
+
+  end
+
+  def self.calculate_local_path path, server
+    "#{@@temp_dir}/#{server},#{path.gsub('/', ',')[1..-1]}"
+  end
+
+  def self.calculate_remote_path path
+    path.gsub(/^#{@@temp_dir}\/.+?,/, '/').gsub(',', '/')
+  end
+
+  def self.init
+    # TODO remove this
+  end
+
+end
+
+Keys.do_as_remote do
+  Remote.save_file
+end
+
+
+# Remote.init

data/lib/requirer.rb

@@ -0,0 +1,46 @@
+require 'core_ext'
+
+class Requirer
+  def self.show txt
+    if ! $el
+      return if txt !~ /(^Xiki requires|exception:$)/
+      return puts "#{txt}"
+    end
+
+    $el.switch_to_buffer "Issues Loading Xiki"
+    $el.insert txt
+    $el.bury_buffer unless $el.buffer_substring($el.point_min, $el.point_max) =~ /(^Xiki requires|exception:$)/
+  end
+
+  def self.require_gem name, options={}
+    begin
+      gem name
+      require options[:name2] || name
+    rescue Exception=>e
+      self.show "Xiki #{options[:optional] ? 'optionally uses' : 'requires'} the '#{name}' gem.\n% sudo gem install #{name}\n\n"
+      raise e if options[:raise]
+    end
+  end
+
+  def self.extract_gem_from_exception txt
+    txt = txt[/-- (.*)/, 1] || txt[/RubyGem (.*)/, 1] || txt[/Could not find (.+?) /, 1] || txt
+
+    return nil if ! txt
+
+    txt.sub!(/\(.+/, '')
+    txt.strip
+  end
+
+  def self.require_classes files
+    files.each do |l|
+      begin
+        require l
+      rescue LoadError => e
+        self.show "#{e.to_s}\n"
+        gem_name = self.extract_gem_from_exception e.to_s
+        self.show "_Xiki requires the '#{gem_name}' gem.\n% sudo gem install #{gem_name}\n\n"
+      end
+    end
+
+  end
+end

data/lib/rest_tree.rb

@@ -0,0 +1,108 @@
+class RestTree
+
+  def self.launch_inner path, children
+
+    self.remove_before_root path
+
+    # Extract verbs from root and current line
+    root_verb = self.extract_root_verb path
+    verb = self.extract_verb path.last
+
+    body = nil
+    # If line had verb
+    if verb
+      if ! path.last.empty?   # If line isn't blank, use as body
+        body = path.last
+        path.pop
+      else
+        # Remove quoted children
+        children = children ? children.select{|e| e !~ /^\|/} : nil
+        if children and children.any?   # If line blank and has children, use them as body
+          body = children.map{|i| "#{i.sub(/^\s+/, '')}\n"}.join('')
+        end
+      end
+    end
+
+    verb ||= root_verb
+
+    [verb || root_verb, path.join(''), body]
+  end
+
+  def self.launch options={}
+
+    Tree.plus_to_minus_maybe
+    verb, url, body = self.launch_inner options[:path], Tree.children
+    url = "http://#{url}" unless url =~ %r"http://"
+
+    result = self.request verb, url, body
+    result = "#{result}\n" unless result =~ /\n\z/
+    result.gsub! "\cm", ''
+
+    # Quote unless begins with "|"
+    result.gsub! /^/, "| "
+    result.gsub! /^\| ( *[-+] )/, "\\1"
+
+    Tree.<< result, :escape=>'', :no_slash=>1
+
+    nil
+  end
+
+  # Tell Launcher whether we're in a rest tree
+  def self.handles? list
+    list.index{|i| i =~ /^(GET|PUT|POST|DELETE)/}
+  end
+
+  # Pull out root
+  def self.extract_root_verb path
+    path.first.sub! /^ *(GET|PUT|POST|DELETE) /, "\\2"
+    $1
+  end
+
+  # Pull out verb
+  def self.extract_verb line
+    line.sub! /^ *(GET|PUT|POST|DELETE) ?(.*)/, "\\2"
+    $1
+  end
+
+  def self.remove_before_root list
+    # Delete from beginning until root is found
+    while list.first !~ /^ *(GET|PUT|POST|DELETE) /
+      break unless list.any?
+      list.shift
+    end
+    list
+  end
+
+  def self.request verb, url, body=nil
+    begin
+      net_http_class = Net::HTTP.const_get(verb.capitalize)
+      url.gsub!('"', '%22')
+      uri = URI.parse(url)
+
+      req = net_http_class.new(uri.request_uri)
+      req.body = body
+      res = Net::HTTP.start(uri.host, uri.port) {|http|
+        http.request(req)
+      }
+      (res.code == '200' ? '' : "#{res.code} ") + res.body
+    rescue Exception=>e
+      e.message
+    end
+
+  end
+
+end
+
+
+Launcher.add(/^.*(- )?GET \/.+/) do
+  line = Line.without_label
+
+  regex, url = /GET \/(.+?)\/ (.+)/.match(line)[1..2]
+  url = "http://#{url}" unless url =~ %r"http://"
+  url.gsub! ' ', '+'
+
+  result = RestTree.request "GET", url
+
+  result = result.grep(/#{regex}/i).join
+  Tree.under result, :no_slash=>1
+end