shoesgem 0.1424.0

data/shoes/ruby/lib/irb/xmp.rb

@@ -0,0 +1,97 @@
+#
+#   xmp.rb - irb version of gotoken xmp
+#   	$Release Version: 0.9$
+#   	$Revision: 21633 $
+#   	by Keiju ISHITSUKA(Nippon Rational Inc.)
+#
+# --
+#
+#   
+#
+
+require "irb"
+require "irb/frame"
+
+class XMP
+  @RCS_ID='-$Id: xmp.rb 21633 2009-01-17 12:19:53Z yugui $-'
+
+  def initialize(bind = nil)
+    IRB.init_config(nil)
+    #IRB.parse_opts
+    #IRB.load_modules
+
+    IRB.conf[:PROMPT_MODE] = :XMP
+
+    bind = IRB::Frame.top(1) unless bind
+    ws = IRB::WorkSpace.new(bind)
+    @io = StringInputMethod.new
+    @irb = IRB::Irb.new(ws, @io)
+    @irb.context.ignore_sigint = false
+
+#    IRB.conf[:IRB_RC].call(@irb.context) if IRB.conf[:IRB_RC]
+    IRB.conf[:MAIN_CONTEXT] = @irb.context
+  end
+
+  def puts(exps)
+    @io.puts exps
+
+    if @irb.context.ignore_sigint
+      begin
+	trap_proc_b = trap("SIGINT"){@irb.signal_handle}
+	catch(:IRB_EXIT) do
+	  @irb.eval_input
+	end
+      ensure
+	trap("SIGINT", trap_proc_b)
+      end
+    else
+      catch(:IRB_EXIT) do
+	@irb.eval_input
+      end
+    end
+  end
+
+  class StringInputMethod < IRB::InputMethod
+    def initialize
+      super
+      @exps = []
+    end
+
+    def eof?
+      @exps.empty?
+    end
+
+    def gets
+      while l = @exps.shift
+	next if /^\s+$/ =~ l
+	l.concat "\n"
+	print @prompt, l
+	break
+      end
+      l
+    end
+
+    def puts(exps)
+      if @encoding and exps.encoding != @encoding
+	enc = Encoding.compatible?(@exps.join("\n"), exps)
+	if enc.nil?
+	  raise Encoding::CompatibilityError, "Encoding in which the passed exression is encoded is not compatible to the preceding's one"
+	else
+	  @encoding = enc
+	end
+      else
+	@encoding = exps.encoding
+      end
+      @exps.concat exps.split(/\n/)
+    end
+
+    attr_reader :encoding
+  end
+end
+
+def xmp(exps, bind = nil)
+  bind = IRB::Frame.top(1) unless bind
+  xmp = XMP.new(bind)
+  xmp.puts exps
+  xmp
+end

data/shoes/ruby/lib/irb.rb

@@ -0,0 +1,354 @@
+#
+#   irb.rb - irb main module
+#   	$Release Version: 0.9.5 $
+#   	$Revision: 24294 $
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+require "e2mmap"
+
+require "irb/init"
+require "irb/context"
+require "irb/extend-command"
+#require "irb/workspace"
+
+require "irb/ruby-lex"
+require "irb/input-method"
+require "irb/locale"
+
+STDOUT.sync = true
+
+module IRB
+  @RCS_ID='-$Id: irb.rb 24294 2009-07-26 15:33:29Z yugui $-'
+
+  class Abort < Exception;end
+
+  #
+  @CONF = {}
+
+  def IRB.conf
+    @CONF
+  end
+
+  # IRB version method
+  def IRB.version
+    if v = @CONF[:VERSION] then return v end
+
+    require "irb/version"
+    rv = @RELEASE_VERSION.sub(/\.0/, "")
+    @CONF[:VERSION] = format("irb %s(%s)", rv, @LAST_UPDATE_DATE)
+  end
+
+  def IRB.CurrentContext
+    IRB.conf[:MAIN_CONTEXT]
+  end
+
+  # initialize IRB and start TOP_LEVEL irb
+  def IRB.start(ap_path = nil)
+    $0 = File::basename(ap_path, ".rb") if ap_path
+
+    IRB.setup(ap_path)
+
+    if @CONF[:SCRIPT]
+      irb = Irb.new(nil, @CONF[:SCRIPT])
+    else
+      irb = Irb.new
+    end
+
+    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
+    @CONF[:MAIN_CONTEXT] = irb.context
+
+    trap("SIGINT") do
+      irb.signal_handle
+    end
+
+    begin
+      catch(:IRB_EXIT) do
+	irb.eval_input
+      end
+    ensure
+      irb_at_exit
+    end
+#    print "\n"
+  end
+
+  def IRB.irb_at_exit
+    @CONF[:AT_EXIT].each{|hook| hook.call}
+  end
+
+  def IRB.irb_exit(irb, ret)
+    throw :IRB_EXIT, ret
+  end
+
+  def IRB.irb_abort(irb, exception = Abort)
+    if defined? Thread
+      irb.context.thread.raise exception, "abort then interrupt!!"
+    else
+      raise exception, "abort then interrupt!!"
+    end
+  end
+
+  #
+  # irb interpreter main routine 
+  #
+  class Irb
+    def initialize(workspace = nil, input_method = nil, output_method = nil)
+      @context = Context.new(self, workspace, input_method, output_method)
+      @context.main.extend ExtendCommandBundle
+      @signal_status = :IN_IRB
+
+      @scanner = RubyLex.new
+      @scanner.exception_on_syntax_error = false
+    end
+    attr_reader :context
+    attr_accessor :scanner
+
+    def eval_input
+      @scanner.set_prompt do
+	|ltype, indent, continue, line_no|
+	if ltype
+	  f = @context.prompt_s
+	elsif continue
+	  f = @context.prompt_c
+	elsif indent > 0
+	  f = @context.prompt_n
+	else
+	  f = @context.prompt_i
+	end
+	f = "" unless f
+	if @context.prompting?
+	  @context.io.prompt = p = prompt(f, ltype, indent, line_no)
+	else
+	  @context.io.prompt = p = ""
+	end
+	if @context.auto_indent_mode
+	  unless ltype
+            ind = prompt(@context.prompt_i, ltype, indent, line_no)[/.*\z/].size +
+	      indent * 2 - p.size
+	    ind += 2 if continue
+	    @context.io.prompt = p + " " * ind if ind > 0
+	  end
+	end
+      end
+       
+      @scanner.set_input(@context.io) do
+	signal_status(:IN_INPUT) do
+	  if l = @context.io.gets
+	    print l if @context.verbose?
+	  else
+	    if @context.ignore_eof? and @context.io.readable_atfer_eof?
+	      l = "\n"
+	      if @context.verbose?
+		printf "Use \"exit\" to leave %s\n", @context.ap_name
+	      end
+	    end
+	  end
+	  l
+	end
+      end
+
+      @scanner.each_top_level_statement do |line, line_no|
+	signal_status(:IN_EVAL) do
+	  begin
+            line.untaint
+	    @context.evaluate(line, line_no)
+	    output_value if @context.echo?
+	    exc = nil
+	  rescue Interrupt => exc
+	  rescue SystemExit, SignalException
+	    raise
+	  rescue Exception => exc
+	  end
+	  if exc
+	    print exc.class, ": ", exc, "\n"
+	    if exc.backtrace[0] =~ /irb(2)?(\/.*|-.*|\.rb)?:/ && exc.class.to_s !~ /^IRB/ &&
+                !(SyntaxError === exc)
+	      irb_bug = true 
+	    else
+	      irb_bug = false
+	    end
+
+	    messages = []
+	    lasts = []
+	    levels = 0
+	    for m in exc.backtrace
+	      m = @context.workspace.filter_backtrace(m) unless irb_bug
+	      if m
+		if messages.size < @context.back_trace_limit
+		  messages.push "\tfrom "+m
+		else
+		  lasts.push "\tfrom "+m
+		  if lasts.size > @context.back_trace_limit
+		    lasts.shift 
+		    levels += 1
+		  end
+		end
+	      end
+	    end
+	    print messages.join("\n"), "\n"
+	    unless lasts.empty?
+	      printf "... %d levels...\n", levels if levels > 0
+	      print lasts.join("\n")
+	    end
+	    print "Maybe IRB bug!!\n" if irb_bug
+	  end
+          if $SAFE > 2
+            abort "Error: irb does not work for $SAFE level higher than 2"
+          end
+	end
+      end
+    end
+
+    def suspend_name(path = nil, name = nil)
+      @context.irb_path, back_path = path, @context.irb_path if path
+      @context.irb_name, back_name = name, @context.irb_name if name
+      begin
+	yield back_path, back_name
+      ensure
+	@context.irb_path = back_path if path
+	@context.irb_name = back_name if name
+      end
+    end
+
+    def suspend_workspace(workspace)
+      @context.workspace, back_workspace = workspace, @context.workspace
+      begin
+	yield back_workspace
+      ensure
+	@context.workspace = back_workspace
+      end
+    end
+
+    def suspend_input_method(input_method)
+      back_io = @context.io
+      @context.instance_eval{@io = input_method}
+      begin
+	yield back_io
+      ensure
+	@context.instance_eval{@io = back_io}
+      end
+    end
+
+    def suspend_context(context)
+      @context, back_context = context, @context
+      begin
+	yield back_context
+      ensure
+	@context = back_context
+      end
+    end
+
+    def signal_handle
+      unless @context.ignore_sigint?
+	print "\nabort!!\n" if @context.verbose?
+	exit
+      end
+
+      case @signal_status
+      when :IN_INPUT
+	print "^C\n"
+	raise RubyLex::TerminateLineInput
+      when :IN_EVAL
+	IRB.irb_abort(self)
+      when :IN_LOAD
+	IRB.irb_abort(self, LoadAbort)
+      when :IN_IRB
+	# ignore
+      else
+	# ignore other cases as well
+      end
+    end
+
+    def signal_status(status)
+      return yield if @signal_status == :IN_LOAD
+
+      signal_status_back = @signal_status
+      @signal_status = status
+      begin
+	yield
+      ensure
+	@signal_status = signal_status_back
+      end
+    end
+
+    def prompt(prompt, ltype, indent, line_no)
+      p = prompt.dup
+      p.gsub!(/%([0-9]+)?([a-zA-Z])/) do
+	case $2
+	when "N"
+	  @context.irb_name
+	when "m"
+	  @context.main.to_s
+	when "M"
+	  @context.main.inspect
+	when "l"
+	  ltype
+	when "i"
+	  if $1 
+	    format("%" + $1 + "d", indent)
+	  else
+	    indent.to_s
+	  end
+	when "n"
+	  if $1 
+	    format("%" + $1 + "d", line_no)
+	  else
+	    line_no.to_s
+	  end
+	when "%"
+	  "%"
+	end
+      end
+      p
+    end
+
+    def output_value
+      if @context.inspect?
+        printf @context.return_format, @context.last_value.inspect
+      else
+        printf @context.return_format, @context.last_value
+      end
+    end
+
+    def inspect
+      ary = []
+      for iv in instance_variables
+	case (iv = iv.to_s)
+	when "@signal_status"
+	  ary.push format("%s=:%s", iv, @signal_status.id2name)
+	when "@context"
+	  ary.push format("%s=%s", iv, eval(iv).__to_s__)
+	else
+	  ary.push format("%s=%s", iv, eval(iv))
+	end
+      end
+      format("#<%s: %s>", self.class, ary.join(", "))
+    end
+  end
+
+  # Singleton method
+  def @CONF.inspect
+    IRB.version unless self[:VERSION]
+
+    array = []
+    for k, v in sort{|a1, a2| a1[0].id2name <=> a2[0].id2name}
+      case k
+      when :MAIN_CONTEXT, :__TMP__EHV__
+	array.push format("CONF[:%s]=...myself...", k.id2name)
+      when :PROMPT
+	s = v.collect{
+	  |kk, vv|
+	  ss = vv.collect{|kkk, vvv| ":#{kkk.id2name}=>#{vvv.inspect}"}
+	  format(":%s=>{%s}", kk.id2name, ss.join(", "))
+	}
+	array.push format("CONF[:%s]={%s}", k.id2name, s.join(", "))
+      else
+	array.push format("CONF[:%s]=%s", k.id2name, v.inspect)
+      end
+    end
+    array.join("\n")
+  end
+end

data/shoes/ruby/lib/json/add/core.rb

@@ -0,0 +1,135 @@
+# This file contains implementations of ruby core's custom objects for
+# serialisation/deserialisation.
+
+unless Object.const_defined?(:JSON) and ::JSON.const_defined?(:JSON_LOADED) and
+  ::JSON::JSON_LOADED
+  require 'json'
+end
+require 'date'
+
+class Time
+  def self.json_create(object)
+    if usec = object.delete('u') # used to be tv_usec -> tv_nsec
+      object['n'] = usec * 1000
+    end
+    if respond_to?(:tv_nsec)
+      at(*object.values_at('s', 'n'))
+    else
+      at(object['s'], object['n'] / 1000)
+    end
+  end
+
+  def to_json(*args)
+    {
+      'json_class' => self.class.name,
+      's' => tv_sec,
+      'n' => respond_to?(:tv_nsec) ? tv_nsec : tv_usec * 1000
+    }.to_json(*args)
+  end
+end
+
+class Date
+  def self.json_create(object)
+    civil(*object.values_at('y', 'm', 'd', 'sg'))
+  end
+
+  alias start sg unless method_defined?(:start)
+
+  def to_json(*args)
+    {
+      'json_class' => self.class.name,
+      'y' => year,
+      'm' => month,
+      'd' => day,
+      'sg' => start,
+    }.to_json(*args)
+  end
+end
+
+class DateTime
+  def self.json_create(object)
+    args = object.values_at('y', 'm', 'd', 'H', 'M', 'S')
+    of_a, of_b = object['of'].split('/')
+    if of_b and of_b != '0'
+      args << Rational(of_a.to_i, of_b.to_i)
+    else
+      args << of_a
+    end
+    args << object['sg']
+    civil(*args)
+  end
+
+  alias start sg unless method_defined?(:start)
+
+  def to_json(*args)
+    {
+      'json_class' => self.class.name,
+      'y' => year,
+      'm' => month,
+      'd' => day,
+      'H' => hour,
+      'M' => min,
+      'S' => sec,
+      'of' => offset.to_s,
+      'sg' => start,
+    }.to_json(*args)
+  end
+end
+
+class Range
+  def self.json_create(object)
+    new(*object['a'])
+  end
+
+  def to_json(*args)
+    {
+      'json_class'   => self.class.name,
+      'a'         => [ first, last, exclude_end? ]
+    }.to_json(*args)
+  end
+end
+
+class Struct
+  def self.json_create(object)
+    new(*object['v'])
+  end
+
+  def to_json(*args)
+    klass = self.class.name
+    klass.to_s.empty? and raise JSON::JSONError, "Only named structs are supported!"
+    {
+      'json_class' => klass,
+      'v'     => values,
+    }.to_json(*args)
+  end
+end
+
+class Exception
+  def self.json_create(object)
+    result = new(object['m'])
+    result.set_backtrace object['b']
+    result
+  end
+
+  def to_json(*args)
+    {
+      'json_class' => self.class.name,
+      'm'   => message,
+      'b' => backtrace,
+    }.to_json(*args)
+  end
+end
+
+class Regexp
+  def self.json_create(object)
+    new(object['s'], object['o'])
+  end
+
+  def to_json(*)
+    {
+      'json_class' => self.class.name,
+      'o' => options,
+      's' => source,
+    }.to_json
+  end
+end

data/shoes/ruby/lib/json/add/rails.rb

@@ -0,0 +1,58 @@
+# This file contains implementations of rails custom objects for
+# serialisation/deserialisation.
+
+unless Object.const_defined?(:JSON) and ::JSON.const_defined?(:JSON_LOADED) and
+  ::JSON::JSON_LOADED
+  require 'json'
+end
+
+class Object
+  def self.json_create(object)
+    obj = new
+    for key, value in object
+      next if key == 'json_class'
+      instance_variable_set "@#{key}", value
+    end
+    obj
+  end
+
+  def to_json(*a)
+    result = {
+      'json_class' => self.class.name
+    }
+    instance_variables.inject(result) do |r, name|
+      r[name[1..-1]] = instance_variable_get name
+      r
+    end
+    result.to_json(*a)
+  end
+end
+
+class Symbol
+  def to_json(*a)
+    to_s.to_json(*a)
+  end
+end
+
+module Enumerable
+  def to_json(*a)
+    to_a.to_json(*a)
+  end
+end
+
+# class Regexp
+#   def to_json(*)
+#     inspect
+#   end
+# end
+#
+# The above rails definition has some problems:
+#
+# 1. { 'foo' => /bar/ }.to_json # => "{foo: /bar/}"
+#    This isn't valid JSON, because the regular expression syntax is not
+#    defined in RFC 4627. (And unquoted strings are disallowed there, too.)
+#    Though it is valid Javascript.
+#
+# 2. { 'foo' => /bar/mix }.to_json # => "{foo: /bar/mix}"
+#    This isn't even valid Javascript.
+