xiki 0.5.0a

data/menus/postgres.rb

@@ -0,0 +1,34 @@
+class Postgres
+
+  def self.name= name
+    @@name = name
+  end
+
+  def self.menu name=nil
+
+    # If no name, list all names
+    if name.nil?
+      return Console.run("psql -c '\\l'", :sync=>true).scan(/^ (\w+)/).map{|i| "- #{i}/"}
+    end
+
+    puts "
+      - .tables/
+      - .create_db :foo
+      - .drop_db :foo
+      "
+  end
+
+  def self.create_db name
+    Console.run "createdb #{name}"
+  end
+
+  def self.drop_db name
+    Console.run "dropdb #{name}"
+  end
+
+  def self.tables db
+    db.sub! /\/$/, ''
+    txt = Console.run "psql #{db} -c '\\d'", :sync=>true
+  end
+
+end

data/menus/pre.rb

@@ -0,0 +1,5 @@
+class Pre
+  def self.menu
+    Browser.html "<pre>#{ENV['txt']}</pre>"
+  end
+end

data/menus/python.rb

@@ -0,0 +1,39 @@
+class Python
+  def self.menu
+    "
+    > Pass python code to run
+    | print('hey')
+    "
+  end
+
+  def self.menu_after txt, *args
+    # Do nothing if .menu created output
+    return nil if txt
+
+    txt = ENV['txt']
+    return nil if txt.nil?
+
+    txt = Python.run_internal txt
+    txt
+  end
+
+  def self.run_block
+    # 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(/^/, '  ')
+    orig.go
+  end
+
+  def self.run_internal txt
+    # Write to temp file
+    File.open("/tmp/tmp.py", "w") { |f| f << txt }
+    # Call js
+    Console.run "python /tmp/tmp.py", :sync=>true
+  end
+end

data/menus/rails.rb

@@ -0,0 +1,160 @@
+require "ruby_console"
+
+class Rails
+
+  CODE_SAMPLES = %q<
+    # Show options to help create new rails app
+    - Show options: Rails.menu
+  >
+
+  def self.menu
+    "
+    - .start/
+    - .generate/
+      - app/
+      - model/
+      - resource/
+      - controller/
+      - scaffold/
+    - .interact/
+      - .rails console/
+      - .sqlite console/
+      - .models/
+    - .setup/
+      - .db/
+        - .migrate/
+      - .use rspec/
+    - .general/
+      - .rails version/
+    "
+  end
+
+  def self.menu_after txt, *args
+    txt
+  end
+
+  def self.menu_before *path
+
+    dir = Projects.current   # Returns dir in tree, or current project (top of projects.menu)
+
+    # Don't intercede if already rails app or trying to generate
+    return nil if ["generate", "general"].member?(path[0]) || File.exists?("#{dir}app")
+
+    # If not a rails dir, give option to generate
+    return "
+      | No rails app in #{dir} yet.  Generate it?
+      - generate/app/
+
+      | Not project-specific
+      - general/
+      "
+  end
+
+  def self.rails_version
+    "| #{`rails --version`}"
+  end
+
+  def self.use_rspec
+    dir = Projects.current
+
+    txt = "
+      @ #{dir}
+        - 1. Add these lines:
+        - Gemfile
+          |+group :development, :test do
+          |+  gem 'rspec-rails'
+          |+end
+        |
+        - 2. Run these commands:
+        % bundle
+        % rails g rspec:install
+        |
+        - 3. Delete the test/ dir:
+        % rm -r test/
+      "
+  end
+
+
+  def self.models
+    dir = Projects.current
+    dir = "#{dir}app/models/"
+
+    entries = Dir.new(dir).entries.select{|o| o =~ /^\w/}
+    entries.map{|o| "@r/#{TextUtil.camel_case o[/\w+/]}.first/"}.join("\n")
+  end
+
+  def self.sqlite_console
+    Console.run "sqlite3 db/development.sqlite3", :dir=>Projects.current, :buffer=>"sqlite console"
+    ".flash - opened console!"
+  end
+
+  def self.rails_console
+    Console.run "rails c", :dir=>Projects.current, :buffer=>"rails console"
+    ".flash - opened console!"
+  end
+
+  def self.generate what, name=nil, detail=nil
+
+    examples = "
+      > Example fields
+      | id:primary_key
+      | name:string
+      | description:text
+      | quantity:integer
+      | price:decimal
+      | purchased_at:datetime
+      | delivery:boolean
+      | user:references
+      ".unindent
+
+    case what
+    when "app"
+      Console.run "rails new . --skip-bundle", :dir=>Projects.current
+      return "- generating rails app..."
+    when "model", "resource", "scaffold"
+      return View.prompt "Enter a name" if ! name
+      return examples if ! detail
+      fields = ENV['txt'].gsub("\n", ' ').strip
+      Console.run "rails g #{what} #{name} #{fields}", :dir=>Projects.current
+      return "- generating #{what}..."
+    when "controller"
+      return View.prompt "Enter a name" if ! name
+      return View.prompt "Enter an action" if ! detail
+      Console.run "rails g controller #{name} #{detail}", :dir=>Projects.current
+      return "- generating controller..."
+    end
+
+    "- Don't know how to generate a '#{what}'!"
+  end
+
+  def self.start *args
+
+    # If 1st arg is number, assume it's the port
+    port = args[0] =~ /^\d+$/ ? args.shift : nil
+
+    # If 'browse', just bring up in browser
+    if args == ['browse']
+      Firefox.url "http://localhost:#{port || 3000}/"
+      return ".flash - opened in browser!"
+    end
+
+    command = "rails s"
+    command << " -p #{port}" if port
+
+    Console.run command, :dir=>Projects.current, :buffer=>"rails server"
+
+    # Check whether it's already running
+    "| Rails app was already running\n- browse/"
+    "| Starting rails app...\n- browse/"
+
+  end
+
+  def self.command txt
+    Console.run txt, :dir=>Projects.current
+  end
+
+  def self.migrate
+    self.command "rake db:migrate"
+  end
+
+end

data/menus/rake.rb

@@ -0,0 +1,12 @@
+class Rake
+  def self.menu task=nil
+
+    if task.nil?   # If no task passed, show all
+      txt = Console.run 'rake -T', :sync=>true
+      return "- Error: no rake file." if txt =~ /^No Rakefile found/
+      return txt.scan(/^rake ([\w:]+)/).join("\n")
+    end
+
+    Console.run "rake #{task}"   # If task passed, run it
+  end
+end

data/menus/redmine.rb

@@ -0,0 +1,168 @@
+require 'net/http'
+require 'uri'
+require 'timeout'
+require 'keys'
+
+class Redmine
+
+  @@url ||= 'http://foo.com:80/wiki/1'
+  def self.url= to;  @@url = to;  end
+  def self.url;  @@url;  end
+
+  def self.menu
+    puts "
+      + .pages/
+      - .start
+      - local: http://localhost:3401/wiki/gateway
+      - remote: http://rlitio.chase.com:3401/wiki/1
+      "
+  end
+
+  def self.pages page=nil
+    if page  # If page was passed, open it
+      self.open page
+      return
+    end
+
+    # Otherwise, print list
+    t = self.http_get "#{@@url}/Page_index/special" rescue return
+    t.scan(/<a href="\/wiki\/1\/([\w-]+)"/) { |m| puts "- #{m[0]}" }
+    ""
+  end
+
+  def self.redmine_to_xiki txt
+
+    # Angle brackets
+    txt.gsub!('&lt;', '<');  txt.gsub!('&gt;', '>')
+    txt.gsub!('&amp;', '&');  txt.gsub!('&quot;', '"')
+
+    (1..7).to_a.reverse.each do |i|  # Headers
+      txt.gsub!(/^#{'#' * i}/, "#{'|' * i} ")
+    end
+    (1..9).to_a.reverse.each do |i|  # Bullets
+      txt.gsub!(/^#{'\\*' * i}/, "#{'  ' * (i-1)}-")
+    end
+
+    txt
+  end
+
+  def self.xiki_to_redmine txt
+    # Headers (h1. etc)
+    (1..7).to_a.reverse.each { |i| txt.gsub!(/^#{'\\|' * i} /, "#{'#' * i}") }
+    (1..9).to_a.reverse.each { |i| txt.gsub!(/^#{'  ' * (i-1)}-/, "#{'*' * i}") }
+    txt
+  end
+
+  def self.open name
+
+    # TODO grab token into a buffer name
+    version = "no_version"
+    wiki, version = self.page_from_server name
+    self.redmine_to_xiki wiki
+    View.to_after_bar
+    View.to_buffer("redmine/#{name}/#{version}")
+
+    # Set mode and use relevant key shortcuts
+    Notes.mode;  $el.use_local_map $el.elvar.redmine_mode_map
+    self.apply_styles
+
+    if View.empty?  # If nothing there yet, insert
+      $el.insert wiki
+    end
+    Move.top
+    ""
+  end
+
+  def self.page_from_server name
+
+    t = self.http_get "#{@@url}/#{name}/edit" rescue
+      return
+    version = t[/<input id="content_version".+value="(\d+)"/, 1]
+    wiki = t[/<textarea.*?>(.+)<\/textarea>/m, 1]
+    wiki.gsub!("\C-m", '')
+    [wiki, version]
+  end
+
+  def self.save
+    name, version = View.buffer_name.split('/')[1..2]
+    txt = View.txt  # Get text from buffer
+    return puts("- Not a redmine page!") unless txt
+    self.xiki_to_redmine txt
+
+    # Get text from server
+    server_txt, server_version = self.page_from_server name
+
+    # If version is same, save
+    if version == server_version
+      res = Net::HTTP.post_form(URI.parse("#{@@url}/#{name}/edit"), {  # Save
+        'content[version]' => version, 'content[text]' => txt
+      })
+      message "- page saved"
+      $el.rename_buffer "redmine/#{name}/#{version.to_i + 1}"  # Rename
+    else  # Otherwise show diff
+      message "- wrong version, show diffs!"
+      View.to_buffer "*redmine_collision: #{name}/#{server_version}"
+      notes_mode;  $el.use_local_map $el.elvar.redmine_mode_map
+
+      View.clear
+      $el.insert "- collision with #{name}/#{server_version}!\n\n"
+      $el.insert self.diff(server_txt, txt)
+    end
+  end
+
+  def self.http_get url
+    t = nil
+    begin
+      timeout(2) do
+        t = Net::HTTP.get URI.parse(url)
+      end
+    rescue Exception => e
+      puts "- Couldn't connect to url (#{url}): #{e.message}!"
+      raise e
+    end
+    t
+  end
+
+  def self.init
+    unless $el.boundp :redmine_mode_map
+      # Create new map
+      $el.elvar.redmine_mode_map = $el.make_sparse_keymap
+      # Inherit notes_mode_map!
+      $el.set_keymap_parent $el.elvar.redmine_mode_map, $el.elvar.notes_mode_map
+    end
+    Keys.XS(:redmine_mode_map) { Redmine.save }
+
+    # Make C-. follow link
+    Launcher.add(/\[\[.+\]\]/) do |line|  # Redmine wiki links
+      name = line[/\[\[(.+?)\]\]/, 1]
+      name.gsub!(/ /, "_")
+      Redmine.open(name)
+    end
+  end
+
+  def self.diff a, b
+    temp_path_a = "/tmp/diff_tmp_a.txt"
+    temp_path_b = "/tmp/diff_tmp_b.txt"
+    File.open(temp_path_a, "w") { |f| f << a }
+    File.open(temp_path_b, "w") { |f| f << b }
+    diff = $el.shell_command_to_string "diff -w -U 0 \"#{temp_path_a}\" \"#{temp_path_b}\""
+    DiffLog.format("server/", "diff/", diff)
+  end
+
+  def self.apply_styles
+    # Strikethrough
+    Styles.define(:strike, :strike => true)
+    Styles.apply("^ *- \\(-.+-\\)$", nil, :strike)
+    # _italic_
+    Styles.define(:redmine_green, :bold => true, :fg => "33dd33")
+    Styles.apply(" _[a-zA-Z0-9 ]+_ ", :redmine_green)
+    Styles.apply(" _[a-zA-Z0-9 ]+_$", :redmine_green)
+
+  end
+
+  def self.start
+    Rails.start '$o/redmine/trunk', @@url[/\d+/]
+  end
+
+end
+# Redmine.init

data/menus/riak_tree.rb

@@ -0,0 +1,204 @@
+gem 'httparty'; require 'httparty'
+gem 'json'; require 'json'
+gem 'riak-client'; require 'riak'
+
+module Riak
+
+  RIAK_URL = "http://127.0.0.1:8098"
+
+  def self.menu
+    [ ".buckets/",
+      ".index/",
+      ".filter/",
+      ".get 'foo/bar'",
+      ".help/",
+      ".log/",
+      ".ping/",
+    ]
+  end
+
+  def self.buckets bucket=nil, key=nil, txt=nil
+
+
+    if key
+      key.sub! /\/$/, ''
+      key.gsub! '/', '%2F'
+      key.sub! /^"(.*)"$/, "\\1"
+    end
+
+    bucket.sub! /\/$/, '' if bucket
+
+    if txt
+      # If 0, delete
+      if Keys.prefix == 0
+        self.delete "#{bucket}/#{key}"
+        return "- deleted!"
+      end
+
+      # Save text if txt passed
+      txt = Tree.siblings :string=>true
+
+      data = YAML::load(txt)
+
+      self.put "#{bucket}/#{key}", YAML::load(txt)
+
+      return "- saved!"
+    end
+
+    # Show contents of object if passed
+    if key
+      Files.append "~/.emacs.d/riak_log.notes", "- Riak.buckets \"#{bucket}\", \"#{key}\"/"
+
+      key = "#{bucket}/#{key}"
+
+      begin
+        return self.get_hash(key).to_yaml.sub(/^--- \n/, '').gsub(/^/, '| ')
+      rescue Exception=>e
+        return self.get_hash(key, :raw=>true).gsub(/^/, '| ')
+      end
+    end
+    # Show contents of bucket if passed
+    return self.get_hash("#{bucket}?keys=true")['keys'].sort.map{|o| "#{o}/"} if bucket
+    # Nothing passed, so list buckets
+    self.get_hash("?buckets=true")["buckets"].sort.map{|o| "#{o}/"}
+  end
+
+  def self.filter bucket=nil, *args
+    bucket.sub! /\/$/, '' if bucket
+
+    if args.any?
+      args = args.join(', ').sub(/\/$/, '')
+
+      Files.append "~/.emacs.d/riak_log.notes", "- Riak.filter \"#{bucket}\", #{args}/"
+
+      args = eval "[#{args}]"
+
+      results = Riak::MapReduce.new(Riak::Client.new).
+        add(bucket, args).
+        map("function(v){ return [v.key]; }", :keep => true).
+        run
+
+      return results.sort.reverse.to_yaml.sub(/\A--- \n/, '').gsub(/^/, '| ')
+    end
+
+    if bucket   # Examples
+      return ["['matches', 'b']/", "['starts_with', 'a']/", "['between', 'a', 'b']/", "['or', [['eq', 'a']], [['less_than', 'g']]]/", "['tokenize', '-', 1], ['eq', 'basho']/"]
+    end
+
+    self.buckets   # Delegate to .buckets to list buckets
+
+  end
+
+  def self.index bucket=nil, search=nil
+
+    if search
+      results = self.get_hash "#{bucket}/index/#{search}", :root=>'buckets'#, :raw=>'true'
+      return results.to_yaml.gsub(/^/, '| ')
+    end
+
+    if bucket   # Examples
+      return ["zip_bin/eq/43215/", "zip_bin/range/40000/49999/"]
+    end
+
+    self.buckets   # Delegate to .buckets to list buckets
+  end
+
+  def self.get path, txt=nil
+
+    if txt
+      txt = Tree.siblings :string=>true
+      self.put path, YAML::load(txt)
+      return "- saved!"
+    end
+
+    hash = self.get_hash(path).to_yaml.sub("--- \n", '').gsub(/^/, '| ')
+
+  end
+
+  def self.get_hash path, options={}
+    begin
+      response = HTTParty.get("#{RIAK_URL}/#{options[:root]||'riak'}/#{path}")
+    rescue Exception=>e
+      raise "Riak not running?"
+    end
+
+    return response.code if response.code.to_s !~ /^2/
+    if options[:raw]
+      response.body
+    else
+      result = ::JSON[response.body]
+      result['_link'] = response.headers['link'].split(', ') if Keys.prefix_u
+      result
+    end
+  end
+
+  def self.post path, options={}
+    # If no body passed in, wrap necessary stuff around it
+    if options[:body].nil?
+      options = {
+        :body=>options.to_json,
+        :headers=>{'Content-Type'=>'application/json'},
+      }
+    end
+
+    HTTParty.post("#{RIAK_URL}/riak/#{path}", options)
+  end
+
+  def self.put path, options={}
+    # If no body passed in, wrap necessary stuff around it
+    if options[:body].nil?
+      options = {
+        :body=>options.to_json,
+        :headers=>{'Content-Type'=>'application/json'},
+      }
+    end
+
+    HTTParty.put("#{RIAK_URL}/riak/#{path}", options)
+    nil
+  end
+
+  def self.delete path
+    HTTParty.delete "#{RIAK_URL}/riak/#{path}"
+  end
+
+  def self.help bucket=nil, key=nil
+    "
+      | To save
+      | - C-enter on object body
+      |
+      | To delete
+      | - C-0, C-enter on object body
+      ".unindent
+  end
+
+  def self.ping
+    `#{Bookmarks['$riak']}/bin/riak ping`
+  end
+
+  def self.log
+    txt = File.read File.expand_path("~/.emacs.d/riak_log.notes")
+    txt = txt.split("\n").reverse.uniq.join("\n")
+  end
+
+end
+
+Keys.enter_list_riak do
+  Launcher.insert '- Riak.menu/'
+end
+
+Keys.enter_list_buckets do
+  Launcher.insert '- buckets/'
+end
+
+Launcher.add("riak") do |path|
+  "
+  - @buckets/
+  "
+end
+
+Launcher.add "buckets" do |path|
+  args = path.split('/')[1..-1]
+  Riak.buckets(*args)
+end
+
+CodeTree.add_menu "Riak"   # Force it, since we're a module