xiki 0.5.0a

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gem 'ruby2ruby'
+gem 'ParseTree'
+gem 'httparty'
+gem 'activesupport'
+gem 'method_source'
+gem 'net-ssh'
+gem 'net-ssh'
+gem 'rspec'
+gem 'memcached'

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2012 Craig D Muth
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,83 @@
+## Summary
+This file tells how to install Xiki.  See http://xiki.org for a description of Xiki.
+
+
+__UPDATE DIRECTIONS TO SAY GEM INSTALL BY DEFAULT__
+
+## Step 1: Download Emacs
+
+### On Mac:
+- Try Aquamacs 1.9.1 if you're new to emacs (it's more mac-like)
+  - http://aquamacs.org/download-classic.shtml
+- Or
+  - http://emacsformacosx.com/emacs-builds/Emacs-22.3-i386-10.5.7.dmg
+- Note: newer mac versions (after 22) have a bug that makes communicating with processes 1000 times slower.  Til this is fixed stick with the above versions.
+
+### On Linux:
+
+      $ sudo apt-get install emacs
+
+
+## Step 2: Install the EmacsRuby (el4r) gem
+
+      $ sudo gem install el4r
+      $ gem contents el4r | grep setup.rb   # To see which dir to cd to in the next step
+      $ cd /Library/Ruby/Gems/1.8/gems/el4r-1.0.4/
+      $ ruby setup.rb
+      $ cd bin/
+      $ ruby -S el4r-rctool -p
+      $ sudo ruby -S el4r-rctool -i
+
+## Step 3: Get Xiki from github
+- Option 1: Download as zip
+  - Click on the 'ZIP' button on http://github.com/trogdoro/xiki
+- Option 2: Clone repo
+  - git clone git@github.com:trogdoro/xiki.git
+
+
+## Step 4: Require Xiki in EmacsRuby's config
+- Sample configuration
+  - ~/.el4r/init.rb
+    | $LOAD_PATH.unshift "/projects/xiki/lib"
+    | require 'xiki'
+    | Xiki.init
+    |
+    | KeyBindings.keys   # Use default key bindings
+    | Styles.use_xiki_color_scheme   # Use xiki's color scheme
+
+
+## Step 5: Install dependant packages
+- In the xiki dir, run:
+$ bundle install --system
+
+
+## Trouble-shooting
+The install is a bit rough at the moment...
+
+- If you get an error (and you probably will)
+  - If you got partially through the load
+    - you will be able to use these keys to trouble-shoot:
+      - Option-l to reload xiki and .emacs
+        - also use this when you see "el4r-instance is dead"
+      - Option-e to look at the latest error
+    - It will be Command instead of Option if you're not using Aquamacs
+
+  - Or you can manually restart emacs (or reload .emacs) and look at the log
+    - Named something like: /tmp/el4r......log
+  - Go to the end and search backward for the last error
+    - probably contains ":Error:"
+
+- If you get a "can't find header dir for ruby" error
+  $ sudo apt-get install ruby1.8-dev
+
+- If you run into trouble installing EmacsRuby
+  - See: http://www.rubyist.net/~rubikitch/computer/el4r/index.en.html
+    - Click on 'Download / Install / Setup' link
+
+
+## Google group
+Join the google group for help with installing, or to chat about whatever or
+share your ideas:
+
+  http://groups.google.com/group/xiki
+

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake'
+require 'spec/rake/spectask'
+
+# Define task
+Spec::Rake::SpecTask.new(:spec) do |t|
+end
+
+task :default  => :spec

data/bin/xiki

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+#
+# > Summary
+# This file is aliased to /usr/local/bin/xiki, so it can be
+# called from the command line.  It exposes xiki menus.
+#
+# > Example
+# $ xiki ip
+#   111.1.1.111
+#
+# To create the alias, see:
+# @xiki/setup/install command/
+#
+
+require 'rubygems'
+
+# Generate with correct path (see below)
+# xiki_dir = "/projects/xiki/"
+xiki_dir = File.expand_path "#{File.dirname(__FILE__)}/.."
+# p "xiki_dir: #{xiki_dir.inspect}"
+
+# $:.unshift xiki_dir #.sub(/\/$/, '')
+$:.unshift "#{xiki_dir}/lib" #.sub(/\/$/, '')
+
+# require "#{xiki_dir}/ol"
+require "ol"
+# Ol.line
+require "core_ext"
+
+$:.unshift "#{xiki_dir}/etc/command"
+# $:.unshift "#{xiki_dir}etc/command/stubs"
+
+require "xiki_command.rb"
+# load "xiki_command.rb"
+
+result = XikiCommand.run
+puts result if result != ""
+
+exit 0
+
+# TODO: Start with template, and when installing, change:
+  # - #!.. line to: result of: `which ruby`
+  # - xiki_dir to: Xiki.dir
+
+

data/etc/command/xiki_command.rb

@@ -0,0 +1,203 @@
+require 'timeout'
+
+#
+# The 'xiki' shell command uses this class to run xiki menus.
+# It tells the xiki process to run menus.  It starts the xiki
+# process if it's not running yet, and the process stays alive
+# until the next time the shell command is run.
+#
+class XikiCommand
+
+  @@dont_show_output = false
+  @@initial_request = nil
+  def self.pop_initial_request
+    tmp = @@initial_request
+    @@initial_request = nil   # So it doesn't loop
+    tmp
+  end
+
+  # Called by the 'xiki' shell command
+  def self.run
+
+    xiki_root = File.expand_path "#{File.dirname(__FILE__)}/../.."
+    argv = ARGV
+
+    if argv.empty?
+      puts self.usage
+      @@dont_show_output = true
+      argv = ['start']   # So it continues on and starts server
+    elsif argv.length == 1 && ['status', 'stop', 'restart'].member?(argv[0])
+      return self.ctrl argv[0]
+    end
+
+    flags, path = argv.partition{|o| o =~ /^-/}
+    path = path.join ' '
+
+    return self.emacs path if flags.member?("-e")   # If -p, just prompt user to type a menu name
+
+    wasnt_running = false
+
+    begin
+      `mkfifo -m 666 /tmp/xikirequest` if ! File.exists?("/tmp/xikirequest")   # Always create first, so they have to be pipes and can't be files
+      `mkfifo -m 666 /tmp/xikiresponse` if ! File.exists?("/tmp/xikiresponse")
+
+      # Try writing to pipe...
+
+      open("/tmp/xikirequest", 'w+') do |out|
+        out.puts path
+        out.flush   # do this when we're done writing data
+        out.close
+      end
+
+      # Try reading from pipe...
+
+      response = self.get_response
+      return response
+
+    rescue Exception=>e
+
+      # If error, remember we have to start the process...
+
+      if e.is_a?(Timeout::Error) || (e.is_a?(Errno::ENOENT) && e.to_s =~ /\/tmp\/xiki/)
+        # Seems like process hasn't been started, so keep going
+        wasnt_running = true
+      else
+        Ol << "Unknown error when trying to call pipe!"
+        Ol << "#{e.to_s}\n#{e.backtrace.join "\n"}"
+        return
+      end
+    end
+
+    process_succeeded = false
+
+    if wasnt_running
+
+      # Start the process...
+
+      require 'daemons'
+
+      begin
+
+        # Shell out as async to start it instead - don't know fucking how
+
+        pid_orig = Process.pid
+
+        @@initial_request = path
+        xiki_process = "#{xiki_root}/etc/command/xiki_process.rb"
+        Daemons.run xiki_process, :ARGV=>['start'], :monitor=>false, :multiple=>false #, :app_name=>'xiki'
+        #         Daemons.run '../etc/command/xiki_process.rb', :ARGV=>['start'], :monitor=>false, :multiple=>false #, :app_name=>'xiki'
+        #         Daemons.run 'etc/process/xiki_process.rb', :ARGV=>['start'], :monitor=>false, :multiple=>false #, :app_name=>'xiki'
+        #         Daemons.run '../etc/process/xiki_process.rb', :ARGV=>['start'], :monitor=>false, :multiple=>false #, :app_name=>'xiki'
+        #         Daemons.run 'xiki_daemon.rb', :ARGV=>['start'], :monitor=>false, :multiple=>false #, :app_name=>'xiki'
+
+        # Aparently this line never gets reached
+        "- Started the process, I think."
+      rescue SystemExit=>e
+        raise SystemExit.new if pid_orig != Process.pid   # If new process that started, just exit
+
+        process_succeeded = true
+
+      rescue Exception=>e
+        puts "- service couldn't start!"
+
+        #rescue ... <Errno::EACCES: Permission denied - /projects/xiki/etc/command/xiki_process.rb.pid>!
+      end
+    end
+
+    if process_succeeded
+      puts self.get_response   # Get response first time
+    end
+
+    raise SystemExit.new
+  end
+
+  def self.get_response
+
+    # Simulate timeout error if process not running
+    process_running = `ps -e` =~ /xiki_process.rb/
+    if ! process_running
+      raise Timeout::Error
+    end
+
+    # TODO: what if menu takes longer than 3 seconds to run?
+
+    # TODO: have process send ACK, so we can make timout short
+
+    timeout(3) do
+    #     timeout(0.5) do
+    #     timeout(1.5) do
+      open("/tmp/xikiresponse", "r+") do |response|
+
+        # old TODO Try using select here, to see if there's data avaliable
+        # old IO.select ["/tmp/xikiresponse"]
+
+        response = response.gets   # will block if there's nothing in the pipe
+
+        response.strip!
+        response.gsub! "\036", "\n"   # Escape linebreaks as 036 char (record separator)
+        response = "" if @@dont_show_output
+        response
+      end
+    end
+  end
+
+  def self.usage
+    %`
+    > Summary
+    This command runs xiki menus, which come from simple files
+    found in ~/menus/.
+
+    > Show all menus
+    % xiki all
+
+    > Examples
+    Call 'ip' menu
+    % xiki ip
+    % xiki animals
+    % xiki tables
+
+    > Open 'ip' menu in emacs
+    % xiki -e ip
+
+    > Run under current dir
+    % xiki -e @git
+
+    > Service
+    Xiki automatically runs a service in the backgroundto keep
+    things fast.
+
+    % xiki   # With no args, it starts the service.
+    % xiki status
+    % xiki stop
+    % xiki restart
+    `.unindent
+  end
+
+  def self.ctrl action
+    require 'daemons'
+    xiki_root = File.expand_path "#{File.dirname(__FILE__)}/../.."
+    xiki_process = "#{xiki_root}/etc/command/xiki_process.rb"
+    Daemons.run(xiki_process, :ARGV=>[action])
+    ""
+  end
+
+  #
+  # Tells emacs to open and display menu.
+  #
+  def self.emacs menu
+
+    # Bring emacs to front
+
+    `open "/Applications/Aquamacs Emacs.app"`
+
+    ruby = %`Menu.external \\"#{menu}\\"`
+    ruby << %`, :dir=>\\"#{Dir.pwd}\\"` if menu =~ /^@/
+
+      command = %`emacsclient -n -e '(el4r-ruby-eval "#{ruby}")'`
+    `#{command}`
+
+    nil
+  end
+
+end
+

data/etc/command/xiki_process.rb

@@ -0,0 +1,52 @@
+# Don't hard-code, generate with script? - or use __file path xiki env var!
+require '/projects/xiki/lib/ol'
+require 'core_ext'
+
+require 'menu'
+
+require 'launcher'
+
+Xiki.init
+
+# Make named pipes for input and output
+
+class XikiProcess
+
+  def self.run
+
+    open('/tmp/xikirequest', 'r+') do |f|
+
+      open('/tmp/xikiresponse', 'w+') do |response|
+        loop do
+
+          # Read request...
+
+          path = XikiCommand.pop_initial_request || f.gets
+          path.strip!
+
+          # Invoke menu and send response...
+
+          menu_output =
+            begin
+              Menu[path]
+            rescue Exception=>e
+              "#{e.message}\n#{e.backtrace.join("\n")}"
+            end
+
+          if menu_output.nil?
+            menu_output = ""
+          end
+
+          menu_output.gsub! "\n", "\036"   # Escape linebreaks as 036 char (record separator)
+          response.puts menu_output
+          response.flush
+        end
+      end
+    end
+
+  rescue Exception=>e
+    puts "#{e.message}\n#{e.backtrace}"
+  end
+end
+
+XikiProcess.run

data/etc/command/xiki_wrapper

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+load "/projects/xiki/bin/xiki"

data/etc/js/menu1.js

@@ -0,0 +1,55 @@
+$(function(){
+  xiki_txt = Xiki.unindent($('div[data-xiki=menu]').html());
+  // Render jquery mobile interface
+
+  $('body').html(Xiki.render_mobile_standalone());
+
+  // Grab children from txt and add menu for each
+  var children = Xiki.children(xiki_txt, "");
+  var html = Xiki.children_to_html(children);
+  //   console.log("html:", html)
+  console.log(".ui-content:", $(".ui-content").length)
+
+  $("div[data-role=content]").html(html);
+  //   $(".ui-content").trigger("create");
+
+  //   $(".ui-page").trigger("create");
+
+  $(document).bind( "pagebeforechange", function(e, data) {
+
+    if(typeof data.toPage != "string") return;
+
+    var hash_orig = data.toPage.replace(/.+?(#|$)/, '');
+    var hash = hash_orig.replace(/,/g, '/');
+
+    Xiki.navigate(e, data, Xiki.children(xiki_txt, hash));
+  });
+
+    // Old
+
+
+
+
+
+
+  //   $("body").trigger("create");
+
+  //   $('div:eq(0)').html("abc");
+  //   $('body').html("abc");
+
+  //   $(".ui-content").blink();
+
+
+  //   $('body').html(Xiki.render_mobile_standalone());
+  //   $("div:first").trigger("create");
+  //   $("div:first").page();
+  //   $("div:first").blink();
+
+  //   $(".ui-page").page();
+  //   $(".ui-page").trigger("refresh");
+  //   $("div[data-role=header]").trigger("create");
+  //   $(".ui-page").trigger("refresh");
+
+  // TODO: pass to xiki.children()
+  //   $('div[data-xiki=menu]').blink();
+})