esruby 0.0.0 → 0.0.2

data/resources/mruby/build/mrbgems/mruby-regexp-pcre/README.md

@@ -1,82 +0,0 @@
-mruby-regexp-pcre
-=================
-
-"mruby-regexp-pcre" is a regular expression module for mruby, based on
-[PCRE](http://pcre.org).
-It provides Regexp and MatchData classes.
-
-
-## Requirements
-
-none (libpcre is bundled).
-
-
-## Example
-
-```Ruby
-line = "#hoge"
-/^#.*/ =~ line
-
-csv = "a, b, c"
-csv.split /,\s*/
-
-kvs = "key: value"
-m = /(\w+)\s*:\s*(\w*)/.match(kvs)
-key, value = m[1], m[2]
-```
-
-## Difference between PCRE and MRI Regexp
-|    | MRI (CRuby) | PCRE |
-|:---|:------------|:-----|
-| \h | A hexdigit character (`[0-9a-fA-F]`) | a horizontal white space character
-
-
-## Test
-If you have mruby source code and imported mruby-regexp-pcre as an mrbgem,
-just run "rake test" to execute test scripts in ``test`` directory:
-```
-% cd mruby
-% rake test
-```
-
-Or run ``run_test.rb`` to check out mruby source code into a temporary directory,
-and run tests on it:
-```
-% cd mruby-regexp-pcre
-% ruby run_test.rb test
-% rm -rf tmp
-```
-
-## Alternatives
-If mruby-regexp-pcre does not meet your requirements, try mruby-onig-regexp.
-It consumes much more memory but has better compatibility with MRI.
-
-- https://github.com/mattn/mruby-onig-regexp (Onigumo/Oniguruma)
-
-Other alternatives:
-
-- https://github.com/mattn/mruby-pcre-regexp (PCRE)
-- https://github.com/masamitsu-murase/mruby-hs-regexp (Henry Spencer's)
-
-
-## License
-
-Copyright (c) 2013 Internet Initiative Japan Inc.
-
-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/resources/mruby/build/mrbgems/mruby-regexp-pcre/mrbgem.rake

@@ -1,63 +0,0 @@
-MRuby::Gem::Specification.new('mruby-regexp-pcre') do |spec|
-  spec.license = 'MIT'
-  spec.authors = 'Internet Initiative Japan Inc.'
-
-  spec.add_dependency 'mruby-string-ext', :core => 'mruby-string-ext'
-
-  ## For dynamic link
-  #spec.linker.libraries << ['pcre']
-
-  ## For static link library
-  # How to use:
-  #  * download pcre library
-  #    $ pwd
-  #    $(mruby.rootdir)/mrbgems/mruby-regexp-pcre
-  #    $ wget http://xxxxx/xxxxx/pcre-X.XX.tar.gz
-  #
-  #  * unpack, setup path
-  #    $ tar zxf pcre-X.XX.tar.gz
-  #    $ mv pcre-X.XX pcre
-  #    $ vim ./mrbgem.rake
-  #    (edit pcre_dirname variable)
-  #
-  #  * move the mruby root dir, make
-  #    $ cd $(mruby.rootdir)
-  #    $ make
-
-  pcre_dirname = 'pcre'
-  pcre_src = "#{spec.dir}/#{pcre_dirname}"
-  spec.cc.include_paths << "#{pcre_src}"
-  spec.cc.flags << '-DHAVE_CONFIG_H'
-  spec.cc.flags << '-DPCRE_STATIC' if /mingw|mswin/ =~ RUBY_PLATFORM
-
-  spec.objs += %W(
-    #{pcre_src}/pcre_byte_order.c
-    #{pcre_src}/pcre_compile.c
-    #{pcre_src}/pcre_config.c
-    #{pcre_src}/pcre_dfa_exec.c
-    #{pcre_src}/pcre_exec.c
-    #{pcre_src}/pcre_fullinfo.c
-    #{pcre_src}/pcre_get.c
-    #{pcre_src}/pcre_globals.c
-    #{pcre_src}/pcre_jit_compile.c
-    #{pcre_src}/pcre_maketables.c
-    #{pcre_src}/pcre_newline.c
-    #{pcre_src}/pcre_ord2utf8.c
-    #{pcre_src}/pcre_refcount.c
-    #{pcre_src}/pcre_string_utils.c
-    #{pcre_src}/pcre_study.c
-    #{pcre_src}/pcre_tables.c
-    #{pcre_src}/pcre_ucd.c
-    #{pcre_src}/pcre_valid_utf8.c
-    #{pcre_src}/pcre_version.c
-    #{pcre_src}/pcre_xclass.c
-    #{pcre_src}/pcre_chartables.c
-  ).map { |f| f.relative_path_from(dir).pathmap("#{build_dir}/%X#{spec.exts.object}" ) }
-
-  desc "generate configuration files for mruby-regexp-pcre"
-  task :regexp_pcre_config do
-    FileUtils.cp "#{pcre_src}/config.h.generic", "#{pcre_src}/config.h"
-    FileUtils.cp "#{pcre_src}/pcre.h.generic", "#{pcre_src}/pcre.h"
-    FileUtils.cp "#{pcre_src}/pcre_chartables.c.dist", "#{pcre_src}/pcre_chartables.c"
-  end
-end

data/resources/mruby/build/mrbgems/mruby-regexp-pcre/mrblib/regexp_pcre.rb

@@ -1,232 +0,0 @@
-class Regexp
-  attr_reader :options
-  attr_reader :source
-  attr_reader :last_match
-
-  def self.quote(str)
-    self.escape(str)
-  end
-
-  def self.compile(*args)
-    self.new(*args)
-  end
-
-  def self.last_match
-    @last_match
-  end
-
-  def =~(str)
-    return nil unless str
-
-    m = self.match(str)
-    if m
-      m.begin(0)
-    else
-      nil
-    end
-  end
-
-  def ===(str)
-    unless str.is_a? String
-      if str.is_a? Symbol
-        str = str.to_s
-      else
-        return false
-      end
-    end
-    self.match(str) != nil
-  end
-
-  def casefold?
-    (@options & IGNORECASE) > 0
-  end
-
-  def to_s
-    s = "(?"
-    s += get_enable_option_string
-
-    if @options & MULTILINE == 0 or @options & IGNORECASE == 0 or @options & EXTENDED == 0
-      s += "-"
-      s += get_disable_option_string
-    end
-
-    s += ":"
-    s += @source
-    s += ")"
-    s
-  end
-
-  def inspect
-    s = "/"
-    s += @source
-    s += "/"
-    s += get_enable_option_string
-    s
-  end
-
-  def get_enable_option_string
-    s = ""
-    s += "m" if @options & MULTILINE > 0
-    s += "i" if @options & IGNORECASE > 0
-    s += "x" if @options & EXTENDED > 0
-    s
-  end
-
-  def get_disable_option_string
-    s = ""
-    s += "m" if @options & MULTILINE == 0
-    s += "i" if @options & IGNORECASE == 0
-    s += "x" if @options & EXTENDED == 0
-    s
-  end
-
-  def self.escape(str)
-    escape_table = {
-      "\ " => '\\ ', # '?\ ' is a space
-      "["  => '\\[',
-      "]"  => '\\]', 
-      "{"  => '\\{', 
-      "}"  => '\\}', 
-      "("  => '\\(', 
-      ")"  => '\\)', 
-      "|"  => '\\|', 
-      "-"  => '\\-', 
-      "*"  => '\\*', 
-      "."  => '\\.', 
-      "\\" => '\\\\',
-      "?"  => '\\?', 
-      "+"  => '\\+', 
-      "^"  => '\\^', 
-      "$"  => '\\$', 
-      "#"  => '\\#', 
-      "\n" => '\\n', 
-      "\r" => '\\r', 
-      "\f" => '\\f', 
-      "\t" => '\\t', 
-      "\v" => '\\v', 
-    }
-
-    s = ""
-    str.each_char do |c|
-      if escape_table[c]
-        s += escape_table[c]
-      else
-        s += c
-      end
-    end
-    s
-  end
-
-  def named_captures
-    h = {}
-    if @names
-      @names.each do |k, v|
-        h[k.to_s] = [v + 1]
-      end
-    end
-    h
-  end
-
-  def names
-    if @names
-      ar = Array.new(@names.size)
-      @names.each do |k, v|
-        ar[v] = k.to_s
-      end
-      ar
-    else
-      []
-    end
-  end
-
-  # private
-  def name_push(name, index)
-    @names ||= {}
-    @names[name.to_sym] = index - 1
-  end
-end
-
-class MatchData
-  attr_reader :regexp
-  attr_reader :string
-
-  def [](n)
-    if n.kind_of?(String) || n.kind_of?(Symbol)
-      indexes = regexp.named_captures[n.to_s]
-      if indexes
-        self[indexes.last]
-      else
-        nil
-      end
-    elsif n.respond_to?(:to_i)
-      # XXX: if n is_a? Range
-      # XXX: when we have 2nd argument...
-      n = n.to_i
-      if n < 0
-        n += self.length
-        return nil if n < 0
-      elsif n >= self.length
-        return nil
-      end
-      b = self.begin(n)
-      e = self.end(n)
-      if b and e
-        @string[b, e-b]
-      else
-        nil
-      end
-    else
-      raise TypeError.new("No implicit converstion of #{n.class} into integer")
-    end
-  end
-
-  def captures
-    self.to_a[1, self.length-1]
-  end
-
-  def inspect
-    if self.length == 1
-      "#<MatchData \"#{self[0]}\">"
-    else
-      idx = 0 
-      capts = self.captures.map! { |s| "#{idx += 1}:#{s.inspect}" }.join(' ')
-      "#<MatchData \"#{self[0]}\" #{capts}>"
-    end 
-  end
-
-  def names
-    self.regexp.names
-  end
-
-  def offset(n)
-    [self.begin(n), self.end(n)]
-  end
-
-  def post_match
-    @string[self.end(0), @string.length]
-  end
-
-  def pre_match
-    @string[0, self.begin(0)]
-  end
-
-  def push(start = nil, finish = nil)
-    @data.push({start: start, finish: finish})
-  end
-
-  def to_a
-    a = []
-    self.length.times { |i| a << self[i] }
-    a
-  end
-
-  def to_s
-    self[0]
-  end
-
-  def values_at(*args)
-    args.map { |i| if i == -self.length then nil else self[i] end }
-  end
-
-  alias size length
-end

data/resources/mruby/build/mrbgems/mruby-regexp-pcre/mrblib/string_pcre.rb

@@ -1,333 +0,0 @@
-class String
-  alias_method :old_index, :index
-  def index(pat, offs=0)
-    return old_index(pat, offs) unless pat.is_a? Regexp
-    if offs < 0
-      offs += self.size
-      return nil if offs < 0
-    end
-    m = pat.match(self, offs)
-    m ? m.begin(0) : nil
-  end
-
-  alias_method :old_sub, :sub
-  def sub(*args, &blk)
-    if args[0].class == String
-      return blk ? old_sub(*args) { |x| blk.call(x) } : old_sub(*args)
-    end
-
-    m = args[0].match(self)
-    return self if !m || m.size == 0
-    r = ''
-    r += m.pre_match
-    r += blk ? blk.call(m[0]) : args[1]
-    r.to_sub_replacement!(m)
-    r += m.post_match
-    r
-  end
-
-  alias_method :old_gsub, :gsub
-  def gsub(*args, &blk)
-    if args[0].class.to_s == 'String'
-      return blk ? old_gsub(*args) { |x| blk.call(x) } : old_gsub(*args)
-    end
-
-    r = ""
-    i = 0
-    while i <= length
-      m = args[0].match(self[i..-1])
-      break if !m || m.size == 0
-
-      r += m.pre_match
-      s = blk ? blk.call(m[0]) : args[1]
-      s.to_sub_replacement!(m)
-      r += s
-
-      if i == length
-        break
-      elsif m.end(0) > 0
-        i += m.end(0)
-      else
-        r += self[i]
-        i += 1
-      end
-    end
-    r += self[i..-1]
-    r
-  end
-
-  def =~(a)
-    begin
-      (a.class.to_s == 'String' ? Regexp.new(a.to_s) : a) =~ self
-    rescue
-      false
-    end
-  end
-
-  alias_method :old_split, :split
-  def split(*args, &blk)
-    return [] if self.empty?
-
-    if args[0].nil? or args[0].class.to_s == 'String'
-      return blk ? old_split(*args) { |x| blk.call(x) } : old_split(*args)
-    end
-
-    if args.size < 2
-      limited = false
-      limit = 0
-    else
-      limit = args[1].to_i
-
-      if limit > 0
-        return [self.dup] if limit == 1
-        limited = true
-      else
-        tail_empty = true
-        limited = false
-      end
-    end
-
-    pattern = args[0]
-    result = []
-    # case '//'
-    if pattern.source.empty?
-      index = 0
-      while true
-        break if limited and limit - result.size <= 1
-        break if index + 1 >= self.length
-
-        result << self[index]
-        index += 1
-      end
-      result << self[index..-1]
-    else
-      start = 0
-      last_match = nil
-      last_match_end = 0
-
-      while m = pattern.match(self, start)
-        break if limited and limit - result.size <= 1
-
-        unless m[0].empty? and (m.begin(0) == last_match_end)
-          result << m.pre_match[last_match_end..-1]
-          result.push(*m.captures)
-        end
-        
-        if m[0].empty?
-          start += 1
-        elsif last_match and last_match[0].empty?
-          start = m.end(0) + 1
-        else
-          start = m.end(0)
-        end
-
-        last_match = m
-        last_match_end = m.end(0) || 0
-
-        break if self.length <= start 
-      end
-
-      if last_match
-        result << last_match.post_match
-      elsif result.empty?
-        result << self.dup
-      end
-    end
-
-    # Trim (not specified in the second argument)
-    if !result.empty? and (limit.nil? || limit == 0)
-      while result.last.nil? or result.last.empty?
-        result.pop
-      end
-    end
-
-    result
-  end
-
-  alias_method :old_slice, :slice
-  alias_method :old_square_brancket, :[]
-
-  def [](*args)
-    return old_square_brancket(*args) unless args[0].class == Regexp
-
-    if args.size == 2
-      match = args[0].match(self)
-      if match
-        if args[1] == 0
-          str = match[0]
-        else
-          str = match.captures[args[1] - 1]
-        end
-        return str
-      end
-    end
-
-    match_data = args[0].match(self)
-    if match_data
-      result = match_data.to_s
-      return result
-    end
-  end
-
-  alias_method :slice, :[]
-  alias_method :old_slice!, :slice!
-  def slice!(*args)
-    return old_slice!(*args) unless args[0].class == Regexp
-
-    result = slice(*args)
-    lm = Regexp.last_match
-    self[*args] = '' if result
-    Regexp.last_match = lm
-    result
-  end
-
-  # private
-  def to_sub_replacement!(match)
-    result = ""
-    index = 0
-    while index < self.length
-      current = index
-      while current < self.length && self[current] != '\\'
-        current += 1
-      end
-      result += self[index, (current - index)]
-      break if current == self.length
-
-      if current == self.length - 1
-        result += '\\'
-        break
-      end
-      index = current + 1
-
-      cap = self[index]
-
-      case cap
-      when "&"
-        result += match[0]
-      when "`"
-        result += match.pre_match
-      when "'"
-        result += match.post_match
-      when "+"
-        result += match.captures.compact[-1].to_s
-      when /[0-9]/
-        result += match[cap.to_i].to_s
-      when '\\'
-        result += '\\'
-      else
-        result += '\\' + cap
-      end
-      index += 1
-    end
-    self.replace(result)
-  end
-
-  alias_method :old_scan, :scan
-  def scan(*args, &blk)
-    return old_scan(*args) if args[0].class == String
-
-    s = self
-    ret = []
-    last_match = nil
-    while m = args[0].match(s)
-      break if !m || m.size == 0
-      return ret if m.end(0) == 0
-
-      val = (m.size == 1 ? m[0] : m.captures)
-      s = m.post_match
-
-      if blk
-        blk.call(val)
-      else
-        ret << val
-      end
-    end
-
-    ret
-  end
-
-
-  #
-  # XXX: Need pull-request to http://github.com/mruby/mruby mrbgems/mruby-string-ext
-  #
-  def []=(*args)
-    index = args[0]
-    if args.size != 3
-      val = args[1]
-      count = nil   
-    else
-      count = args[1]
-      val = args[2]
-    end
-
-    case index
-    when Fixnum
-      index += self.size if index < 0
-
-      raise IndexError, "index #{index} out of string" if index < 0 or index > self.size
-      raise IndexError, "unable to find charactor at: #{index}" unless bi = index
-
-      if count
-        count = count.to_i
-        raise IndexError, "count is negative" if count < 0
-
-        total = index + count
-        bs = total - bi
-      else
-        bs = index == size ? 0 : (index + 1) - bi
-      end
-
-      splice bi, bs, val
-    when String
-      raise IndexError, "string not matched" unless start = self.index(index)
-
-      splice start, index.size, val
-    when Range
-      start = index.first.to_i
-      start += self.size if start < 0
-
-      raise RangeError, "#{index.first} is out of range" unless bi = start
-      stop = index.last.to_i
-      stop += self.size if stop < 0
-      stop -= 1 if index.exclude_end?
-
-      if stop < start
-        bs = 0
-      else
-        bs =  stop + 1 - bi
-      end
-
-      splice bi, bs, val
-    when Regexp
-      count = count || 0
-
-      if match = index.match(self)
-        ms = match.size
-      else
-        raise IndexError, "regexp does not match"
-      end
-
-      count += ms if count < 0 and -count < ms
-      raise IndexError, "index #{count} out of match bounds" unless count < ms and count >= 0
-
-      bi = match.begin(count)
-      bs = match.end(count) - bi
-
-      splice bi, bs, val
-    else
-      index = index.to_i
-
-      if count
-        return self[index, count] = val
-      else
-        return self[index] = val
-      end
-    end
-
-    return val
-  end
-
-  def splice(start , count, val)
-    self.replace(self[0...start] + val + self[(start + count)..-1].to_s)
-  end
-end