laser 0.7.0.pre1

data/lib/laser/standard_library/abbrev.rb

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+=begin
+#
+# Copyright (c) 2001,2003 Akinori MUSHA <knu@iDaemons.org>
+#
+# All rights reserved.  You can redistribute and/or modify it under
+# the same terms as Ruby.
+#
+# $Idaemons: /home/cvs/rb/abbrev.rb,v 1.2 2001/05/30 09:37:45 knu Exp $
+# $RoughId: abbrev.rb,v 1.4 2003/10/14 19:45:42 knu Exp $
+# $Id: abbrev.rb 25189 2009-10-02 12:04:37Z akr $
+=end
+
+# Calculate the set of unique abbreviations for a given set of strings.
+#
+#   require 'abbrev'
+#   require 'pp'
+#
+#   pp Abbrev::abbrev(['ruby', 'rules']).sort
+#
+# <i>Generates:</i>
+#
+#   [["rub", "ruby"],
+#    ["ruby", "ruby"],
+#    ["rul", "rules"],
+#    ["rule", "rules"],
+#    ["rules", "rules"]]
+#
+# Also adds an +abbrev+ method to class +Array+.
+
+module Abbrev
+
+  # Given a set of strings, calculate the set of unambiguous
+  # abbreviations for those strings, and return a hash where the keys
+  # are all the possible abbreviations and the values are the full
+  # strings. Thus, given input of "car" and "cone", the keys pointing
+  # to "car" would be "ca" and "car", while those pointing to "cone"
+  # would be "co", "con", and "cone".
+  #
+  # The optional +pattern+ parameter is a pattern or a string. Only
+  # those input strings matching the pattern, or begging the string,
+  # are considered for inclusion in the output hash
+
+  def abbrev(words, pattern = nil)
+    table = {}
+    seen = Hash.new(0)
+
+    if pattern.is_a?(String)
+      pattern = /^#{Regexp.quote(pattern)}/	# regard as a prefix
+    end
+
+    words.each do |word|
+      next if (abbrev = word).empty?
+      while (len = abbrev.rindex(/[\w\W]\z/)) > 0
+	abbrev = word[0,len]
+
+	next if pattern && pattern !~ abbrev
+
+	case seen[abbrev] += 1
+	when 1
+	  table[abbrev] = word
+	when 2
+	  table.delete(abbrev)
+	else
+	  break
+	end
+      end
+    end
+
+    words.each do |word|
+      next if pattern && pattern !~ word
+
+      table[word] = word
+    end
+
+    table
+  end
+
+  module_function :abbrev
+end
+
+class Array
+  # Calculates the set of unambiguous abbreviations for the strings in
+  # +self+. If passed a pattern or a string, only the strings matching
+  # the pattern or starting with the string are considered.
+  #
+  #   %w{ car cone }.abbrev   #=> { "ca" => "car", "car" => "car",
+  #                                 "co" => "cone", "con" => cone",
+  #                                 "cone" => "cone" }
+  def abbrev(pattern = nil)
+    Abbrev::abbrev(self, pattern)
+  end
+end
+
+if $0 == __FILE__
+  while line = gets
+    hash = line.split.abbrev
+
+    hash.sort.each do |k, v|
+      puts "#{k} => #{v}"
+    end
+  end
+end

data/lib/laser/standard_library/array.rb

@@ -0,0 +1,418 @@
+class Array
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  def self.[](*args)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  def &(other_ary)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  def |(other_ary)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  def *(int_or_str)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  def +(other_ary)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  def -(other_ary)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  def <<(obj)
+  end
+  # pure: true
+  # builtin: true
+  def <=>(other_ary)
+  end
+  # pure: true
+  # builtin: true
+  def ==(other_ary)
+  end
+  # pure: true
+  # builtin: true
+  def [](*args)
+  end
+  # pure: true
+  # builtin: true
+  def []=(*args)
+  end
+  # pure: true
+  # builtin: true
+  def assoc(obj)
+  end
+  # pure: true
+  # builtin: true
+  def at(index)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  def clear
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def collect
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def collect!
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def combination(n)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  def compact
+  end
+  # pure: true
+  # builtin: true
+  def compact!
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  def concat(other_ary)
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def count(*args)
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def cycle(n=nil)
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def delete(obj)
+  end
+  # pure: true
+  # builtin: true
+  def delete_at(index)
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def delete_if
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  def drop(n)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  # yield_usage: optional
+  def drop_while
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  # returns: Array=
+  def each
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def each_index
+  end
+  # pure: true
+  # builtin: true
+  def empty?
+  end
+  # pure: true
+  # builtin: true
+  def eql?(other_ary)
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def fetch(*args)
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def fill(*args)
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def find_index(*args)
+  end
+  # pure: true
+  # builtin: true
+  def first(*args)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array= | NilClass
+  def flatten(*args)
+  end
+  # pure: true
+  # builtin: true
+  def flatten!(*args)
+  end
+  # pure: true
+  # builtin: true
+  def frozen?
+  end
+  # pure: true
+  # builtin: true
+  def hash
+  end
+  # pure: true
+  # builtin: true
+  def include?(obj)
+  end
+  # pure: true
+  # builtin: true
+  def index(*args)
+  end
+  # pure: true
+  # builtin: true
+  def insert(index, *obj)
+  end
+  # pure: true
+  # builtin: true
+  def inspect
+  end
+  # pure: true
+  # builtin: true
+  def join(sep=$,)
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def keep_if
+  end
+  # pure: true
+  # builtin: true
+  def last(*arg)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  # yield_usage: optional
+  def map
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def map!
+  end
+  # pure: true
+  # builtin: true
+  def pack(template_string)
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def permutation(*arg)
+  end
+  # pure: true
+  # builtin: true
+  def pop(*arg)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  # yield_usage: optional
+  def product(other_ary, *rest)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  def push(obj, *rest)
+  end
+  # pure: true
+  # builtin: true
+  def rassoc(obj)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  # yield_usage: optional
+  def reject
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def reject!
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def repeated_combination(n)
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def repeated_permutation(n)
+  end
+  # pure: true
+  # builtin: true
+  def replace(other_ary)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  def reverse
+  end
+  # pure: true
+  # builtin: true
+  def reverse!
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def reverse_each
+  end
+  # pure: true
+  # builtin: true
+  def rindex(*obj_or_not)
+  end
+  # pure: true
+  # builtin: true
+  def rotate(n=1)
+  end
+  # pure: true
+  # builtin: true
+  def rotate!(cnt=1)
+  end
+  # builtin: true
+  # predictable: false
+  def sample(*n_or_not)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  # yield_usage: optional
+  def select
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def select!
+  end
+  # pure: true
+  # builtin: true
+  def shift(*n_or_not)
+  end
+  # builtin: true
+  # predictable: false
+  # returns: Array=
+  def shuffle
+  end
+  # builtin: true
+  # predictable: false
+  def shuffle!
+  end
+  # pure: true
+  # raise: false
+  # builtin: true
+  # returns: Fixnum=
+  def size
+  end
+  alias length size
+  # pure: true
+  # builtin: true
+  def slice(*args)
+  end
+  # pure: true
+  # builtin: true
+  def slice!(*args)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  # yield_usage: optional
+  def sort
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def sort!
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def sort_by!
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  def take(n)
+  end
+  # pure: true
+  # builtin: true
+  # yield_usage: optional
+  def take_while
+  end
+  # pure: true
+  # raise: false
+  # builtin: true
+  # returns: Array=
+  def to_a
+  end
+  # pure: true
+  # raise: false
+  # builtin: true
+  # returns: Array=
+  def to_ary
+  end
+  # pure: true
+  # builtin: true
+  # returns: String=
+  def to_s
+  end
+  # pure: true
+  # builtin: true
+  def transpose
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  def uniq
+  end
+  # pure: true
+  # builtin: true
+  def uniq!
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  def unshift(obj, *objs)
+  end
+  # pure: true
+  # builtin: true
+  def values_at(selector, *selectors)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  # yield_usage: optional
+  def zip(arg, *args)
+  end
+end