readline-ffi 0.0.2

data/.gitignore

@@ -0,0 +1,2 @@
+/nbproject/private/
+*.gem

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+gemspec
+

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 Koichiro Ohba. All rights reserved.
+
+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.rdoc

@@ -0,0 +1,9 @@
+= Readline-ffi
+
+GNU Readline Wrapper for Ruby-FFI(JRuby-FFI/Rubinus-FFI/Ruby-FFI).
+
+CRuby's Readline extention intaerface compatiblity.
+
+tested only JRuby Windows environment.
+
+I hope supoorts environments to Mac OSX and Linux.

data/Rakefile

@@ -0,0 +1,37 @@
+# -*- mode: ruby; coding: utf-8 -*-
+require 'rubygems'
+require 'bundler'
+
+require 'rake'
+require 'rake/clean'
+require 'rake/rdoctask'
+require 'fileutils'
+include FileUtils
+
+CLEAN.include ["ext/*.{log,c,so,obj,pdb,lib,def,exp,manifest,orig}", "ext/Makefile", "*.gem"]
+
+name="readline-ffi"
+version="0.0.1"
+
+desc "Do everything, baby!"
+task :default => [:package]
+
+task :package => [:clean,:compile,:makegem]
+
+task :ffi_generate do
+  require 'ffi'
+  require 'ffi/tools/generator'
+  require 'ffi/tools/struct_generator'
+
+  ffi_files = ["lib/readline.rb.ffi"]
+  ffi_options = "-Ilib"
+  ffi_files.each do |ffi_file|
+    
+  end
+  
+end
+
+desc "mspec"
+task :spec do
+  sh "mspec -t j spec"
+end

data/lib/ffi/readline.rb

@@ -0,0 +1,71 @@
+require 'ffi'
+
+module FFI::Readline
+  extend FFI::Library
+  CONVENTION = FFI::Platform.windows? ? :stdcall : :default
+
+  paths = %w[
+    /usr/local/lib/libreadline.dylib
+    /opt/local/lib/libreadline.dylib
+    /usr/lib/libreadline.dylib
+    /usr/lib/libreadline.so
+    /lib/libreadline.so
+    /lib/libreadline.so.5
+  ]
+  paths << File.expand_path(File.dirname(__FILE__) + "/../../ext/readline.dll")
+  paths.find do |path|
+    if File.exist?(path)
+      begin
+        ffi_lib path
+        true
+      rescue LoadError
+        false
+      end
+    end
+  end
+  ffi_convention(CONVENTION)
+
+  attach_function :readline, [:string], :string
+  attach_function :filename_completion_function, :rl_filename_completion_function, [:pointer, :int], :pointer
+  attach_function :username_completion_function, :rl_username_completion_function, [:string, :int], :string
+  callback :compentry_function, [:pointer, :int], :string
+  attach_function :completion_matches, :rl_completion_matches, [:string, :compentry_function], :pointer
+  attach_function :refresh_line, :rl_refresh_line, [:int, :int], :int
+
+  attach_variable :library_version, :rl_library_version, :pointer
+  attach_variable :readline_name, :rl_readline_name, :pointer
+  attach_variable :editing_mode, :rl_editing_mode, :int
+  attach_variable :insert_mode, :rl_insert_mode, :int
+  attach_variable :completion_entry_function, :rl_completion_entry_function, :pointer
+  attach_variable :completion_append_character, :rl_completion_append_character, :int
+  attach_variable :completer_quote_characters, :rl_completer_quote_characters, :pointer
+  attach_variable :filename_quote_characters, :rl_filename_quote_characters, :pointer
+  attach_variable :basic_quote_characters, :rl_basic_quote_characters, :pointer
+  attach_variable :basic_word_break_characters, :rl_basic_word_break_characters, :pointer
+  attach_variable :completer_word_break_characters, :rl_completer_word_break_characters, :pointer
+  callback :completion_function, [:string, :int, :int], :pointer
+  attach_variable :attempted_completion_function, :rl_attempted_completion_function, :completion_function
+  attach_variable :outstream, :rl_outstream, :pointer
+  attach_variable :instream, :rl_instream, :pointer
+
+  # History
+  class HistoryEntry < FFI::Struct
+    layout :line, :string, 0,
+           :timstamp, :string, 4,
+           :data, :pointer, 8
+  end
+
+  attach_function :using_history, [], :void
+  attach_function :add_history, [:string], :void
+#  attach_function :add_history_time, [:string], :void
+  attach_function :clear_history, [], :void
+  attach_function :remove_history, [:int], :pointer
+  attach_function :history_get, [:int], :pointer
+  attach_function :replace_history_entry, [:int, :string, :pointer], :pointer
+
+  attach_variable :history_base, :int
+  attach_variable :history_length, :int
+  attach_variable :history_max_entries, :int
+end
+
+

data/lib/readline-ffi/version.rb

@@ -0,0 +1,3 @@
+module ReadlineFFI
+  VERSION = '0.0.2'
+end

data/lib/readline.rb

@@ -0,0 +1,300 @@
+#
+# Version: CPL 1.0/GPL 2.0/LGPL 2.1
+#
+# The contents of this file are subject to the Common Public
+# License Version 1.0 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.eclipse.org/legal/cpl-v10.html
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# Copyright (C) 2009 Koichiro Ohba <koichiro@meadowy.org>
+#
+# Alternatively, the contents of this file may be used under the terms of
+# either of the GNU General Public License Version 2 or later (the "GPL"),
+# or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+# in which case the provisions of the GPL or the LGPL are applicable instead
+# of those above. If you wish to allow use of your version of this file only
+# under the terms of either the GPL or the LGPL, and not to allow others to
+# use your version of this file under the terms of the CPL, indicate your
+# decision by deleting the provisions above and replace them with the notice
+# and other provisions required by the GPL or the LGPL. If you do not delete
+# the provisions above, a recipient may use your version of this file under
+# the terms of any one of the CPL, the GPL or the LGPL.
+
+require 'ffi/readline'
+require 'readeline-ffi/version'
+
+module Readline
+
+  # filename_completion_proc_call
+  FILENAME_COMPLETION_PROC = Proc.new do |text|
+#    p = FFI::Readline.completion_matches(text) do |word, state|
+#      puts word
+#      puts word_p.read_string
+#      puts state
+#      p = FFI::Readline.filename_completion_function(word_p, state)
+#      nil
+#      p = ::FFI::MemoryPointer.new :pointer
+#      p.put_string("hoge")
+#      p
+#      nil
+#    end
+#    return nil if p.null?
+
+    r = Dir.glob(text + "*")
+    p r
+    r
+  end
+  # username_completion_proc_call
+  USERNAME_COMPLETION_PROC = Proc.new do |text|
+    []
+  end
+
+  # Readline initialize
+  private
+  FFI::Readline.readline_name = ::FFI::MemoryPointer.from_string("Ruby")
+  @completion_proc = nil
+  @completion_case_fold = nil
+
+  def self.library_version
+    p = FFI::Readline.library_version
+    p.null? ? nil : p.read_string
+  end
+
+  ATTEMPTED_COMPLETION_PROC = lambda do |text, start, last|
+    proc = @completion_proc
+    return nil unless proc
+
+    candidates = proc.call(text)
+    return nil if candidates.empty?
+
+    result_size = candidates.length + 1
+    result = ::FFI::MemoryPointer.new :pointer, result_size
+    candidates.each_with_index do |word, i|
+      result[i].put_pointer(0, ::FFI::MemoryPointer.from_string(word))
+    end
+    result[result_size - 1].put_pointer(0, nil)
+
+    result
+  end
+  FFI::Readline.attempted_completion_function = ATTEMPTED_COMPLETION_PROC
+
+  public
+  VERSION = "#{library_version} (FFI wrapper #{ReadelineFFI::VERSION})"
+
+  def readline( prompt = "", history = nil)
+    raise TypeError unless STDIN.kind_of? IO
+    raise TypeError unless STDOUT.kind_of? IO
+    # TODO: STDOUT,STDIN connected in rl_outstream, rl_instream
+    # FFI::Readline.instream
+    # FFI::Readline.outstream
+
+    r = FFI::Readline.readline(prompt)
+    if history
+      FFI::Readline.add_history(r)
+    end
+    r.taint
+  end
+  module_function :readline
+
+  class History
+    include Enumerable
+
+    private
+    def initialize
+      FFI::Readline.using_history
+    end
+
+    def remove_history(index)
+      p = FFI::Readline.remove_history(index)
+      return nil if p.null?
+      entry = FFI::Readline::HistoryEntry.new(p)
+      String.new(entry[:line])
+    end
+
+    public
+    def to_s; "HISTORY" end
+
+    def [](index)
+      index += FFI::Readline.history_length if index < 0
+      p = FFI::Readline.history_get(FFI::Readline.history_base + index)
+      raise IndexError, "invalid index" if p.null?
+      entry = FFI::Readline::HistoryEntry.new(p)
+      entry[:line].taint
+    end
+
+    def []=(index, str)
+      index += FFI::Readline.hisrory_length if index < 0
+      p = FFI::Readline.replace_history_entry(index, str, nil)
+      raise IndexError, "invalid index" if p.null?
+      str
+    end
+
+    def <<(str)
+      raise TypeError unless str.respond_to?(:to_str)
+
+      FFI::Readline.add_history(str.to_str)
+      HISTORY
+    end
+    
+    def push(*args)
+      for s in args
+        raise TypeError unless s.respond_to?(:to_str)
+        FFI::Readline.add_history(s.to_str)
+      end
+      HISTORY
+    end
+    
+    def pop
+      l = FFI::Readline.history_length
+      return nil if l <= 0
+      r = remove_history(l - 1)
+      r.taint
+    end
+    
+    def shift
+      return nil unless FFI::Readline.history_length > 0
+      r = remove_history(0)
+      r.taint
+    end
+    
+    def each(&block)
+      i = 0
+      while i < FFI::Readline.history_length
+        p = FFI::Readline.history_get(FFI::Readline.history_base + i)
+        break if p.null?
+        entry = FFI::Readline::HistoryEntry.new(p)
+        block.call(String.new(entry[:line]).taint)
+        i += 1
+      end
+      self
+    end
+    
+    def length
+      FFI::Readline.history_length
+    end
+    alias :size :length
+    
+    def empty?
+      FFI::Readline.history_length == 0 ? true : false
+    end
+
+    def delete_at(index)
+      l = FFI::Readline.history_length
+      index += l if index < 0
+      raise IndexError, "invalid index" if (index < 0) or (index > l - 1)
+      r  = remove_history(index)
+      r.taint
+    end
+  end
+  HISTORY = History.new
+
+  def self.basic_word_break_characters=(str)
+    return nil unless str
+    FFI::Readline.basic_word_break_characters = ::FFI::MemoryPointer.from_string(str)
+  end
+
+  def self.basic_word_break_characters
+    p = FFI::Readline.basic_word_break_characters
+    p.null? ? nil : p.read_string
+  end
+  
+  def self.completion_append_character=(str)
+    if str
+      FFI::Readline.completion_append_character = str[0]
+    else
+      FFI::Readline.completion_append_character = 0
+    end
+  end
+
+  def self.completion_append_character
+    ch = FFI::Readline.completion_append_character
+    return nil if ch == 0
+    ch.chr
+  end
+
+  def self.completer_word_break_characters=(str)
+    return nil unless str
+    FFI::Readline.completer_word_break_characters = ::FFI::MemoryPointer.from_string(str)
+  end
+
+  def self.completer_word_break_characters
+    p = FFI::Readline.completer_word_break_characters
+    p.null? ? nil : p.read_string
+  end
+
+  def self.basic_quote_characters=(str)
+    return nil unless str
+    FFI::Readline.basic_quote_characters = ::FFI::MemoryPointer.from_string(str)
+    HISTORY
+  end
+
+  def self.basic_quote_characters
+    p = FFI::Readline.basic_quote_characters
+    p.null? ? nil : p.read_string
+  end
+
+  def self.completer_quote_characters=(str)
+    return nil unless str
+    FFI::Readline.completer_quote_characters = ::FFI::MemoryPointer.from_string(str)
+  end
+
+  def self.completer_quote_characters
+    p = FFI::Readline.completer_quote_characters
+    p.null? ? nil : p.read_string
+  end
+
+  def self.filename_quote_characters=(str)
+    return nil unless str
+    FFI::Readline.completer_quote_characters = ::FFI::MemoryPointer.from_string(str)
+  end
+
+  def self.filename_quote_characters
+    p = FFI::Readline.filename_quote_characters
+    p.null? ? nil : p.read_string
+  end
+
+  def self.completion_proc=(proc)
+    raise ArgumentError, "argument must respond to `call'" unless proc.respond_to? :call
+    @completion_proc = proc
+  end
+
+  def self.completion_proc
+    @completion_proc
+  end
+
+  def self.completion_case_fold=(bool)
+    @completion_case_fold = bool
+  end
+  
+  def self.completion_case_fold
+    @completion_case_fold
+  end
+
+  def self.vi_editing_mode
+    FFI::Readline.editing_mode = 0
+    nil
+  end
+
+  def self.emacs_editing_mode
+    FFI::Readline.editing_mode = 1
+    nil
+  end
+
+  def self.refresh_line()
+    FFI::Readline.refresh_line(0, 0)
+  end
+end
+
+if __FILE__ == $0
+  r = Readline.readline("hoge> ")
+  puts ">> " + r
+  puts FFI::Readline.editing_mode
+  puts Readline.emacs_editing_mode
+  puts Readline.completer_quote_characters
+  puts Readline.basic_word_break_characters
+end