rubysl-scanf 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1ed897434fc0fa9f3bfd5140a40a5e22f7d27d16
+  data.tar.gz: 961948512402b24eb0d7bf8f35133ec125bcfeb7
+SHA512:
+  metadata.gz: b5d25523fd14c89c3dd7fac10e788868b051ebd8960dec0b927cc829e11e76d7fab0a126bcb7b04b2c89a318777ca9d58c1e712b6f8bb8144dcec7e9407a8e28
+  data.tar.gz: d78c75093ba32f6a69647140b223a8f3426b523051ed1b54ddcf2cf427cd2e98def5fbac2914c4bab5c9660bcf6aeb28616246ea573759662ec334828c040ca6

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+before_install:
+  - gem update --system
+  - gem --version
+  - gem install rubysl-bundler
+script: bundle exec mspec spec
+rvm:
+  - rbx-nightly-18mode

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rubysl-scanf.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2013, Brian Shirai
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+3. Neither the name of the library nor the names of its contributors may be
+   used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,29 @@
+# Rubysl::Scanf
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rubysl-scanf'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rubysl-scanf
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/rubysl/scanf.rb

@@ -0,0 +1,2 @@
+require "rubysl/scanf/scanf"
+require "rubysl/scanf/version"

data/lib/rubysl/scanf/scanf.rb

@@ -0,0 +1,703 @@
+# scanf for Ruby
+#
+# $Revision: 21682 $
+# $Id: scanf.rb 21682 2009-01-20 03:23:46Z shyouhei $
+# $Author: shyouhei $
+# $Date: 2009-01-19 19:23:46 -0800 (Mon, 19 Jan 2009) $
+#
+# A product of the Austin Ruby Codefest (Austin, Texas, August 2002)
+
+=begin
+
+=scanf for Ruby
+
+==Description
+
+scanf for Ruby is an implementation of the C function scanf(3),
+modified as necessary for Ruby compatibility.
+
+The methods provided are String#scanf, IO#scanf, and
+Kernel#scanf. Kernel#scanf is a wrapper around STDIN.scanf.  IO#scanf
+can be used on any IO stream, including file handles and sockets.
+scanf can be called either with or without a block.
+
+scanf for Ruby scans an input string or stream according to a
+<b>format</b>, as described below ("Conversions"), and returns an
+array of matches between the format and the input.  The format is
+defined in a string, and is similar (though not identical) to the
+formats used in Kernel#printf and Kernel#sprintf.
+
+The format may contain <b>conversion specifiers</b>, which tell scanf
+what form (type) each particular matched substring should be converted
+to (e.g., decimal integer, floating point number, literal string,
+etc.)  The matches and conversions take place from left to right, and
+the conversions themselves are returned as an array.
+
+The format string may also contain characters other than those in the
+conversion specifiers.  White space (blanks, tabs, or newlines) in the
+format string matches any amount of white space, including none, in
+the input.  Everything else matches only itself.
+
+Scanning stops, and scanf returns, when any input character fails to
+match the specifications in the format string, or when input is
+exhausted, or when everything in the format string has been
+matched. All matches found up to the stopping point are returned in
+the return array (or yielded to the block, if a block was given).
+
+
+==Basic usage
+
+   require 'scanf.rb'
+
+   # String#scanf and IO#scanf take a single argument (a format string)
+   array = aString.scanf("%d%s")
+   array = anIO.scanf("%d%s")
+
+   # Kernel#scanf reads from STDIN
+   array = scanf("%d%s")
+
+==Block usage
+
+When called with a block, scanf keeps scanning the input, cycling back
+to the beginning of the format string, and yields a new array of
+conversions to the block every time the format string is matched
+(including partial matches, but not including complete failures).  The
+actual return value of scanf when called with a block is an array
+containing the results of all the executions of the block. 
+
+   str = "123 abc 456 def 789 ghi"
+   str.scanf("%d%s") { |num,str| [ num * 2, str.upcase ] }
+     # => [[246, "ABC"], [912, "DEF"], [1578, "GHI"]]
+
+==Conversions
+
+The single argument to scanf is a format string, which generally
+includes one or more conversion specifiers. Conversion specifiers
+begin with the percent character ('%') and include information about
+what scanf should next scan for (string, decimal number, single
+character, etc.).
+
+There may be an optional maximum field width, expressed as a decimal
+integer, between the % and the conversion. If no width is given, a
+default of `infinity' is used (with the exception of the %c specifier;
+see below).  Otherwise, given a field width of <em>n</em> for a given
+conversion, at most <em>n</em> characters are scanned in processing
+that conversion.  Before conversion begins, most conversions skip
+white space in the input string; this white space is not counted
+against the field width.
+
+The following conversions are available. (See the files EXAMPLES
+and <tt>tests/scanftests.rb</tt> for examples.)
+
+[%]
+  Matches a literal `%'. That is, `%%' in the format string matches a
+  single input `%' character. No conversion is done, and the resulting
+  '%' is not included in the return array.
+
+[d]
+  Matches an optionally signed decimal integer.
+
+[u]
+  Same as d.
+
+[i] 
+  Matches an optionally signed integer. The integer is read in base
+  16 if it begins with `0x' or `0X', in base 8 if it begins with `0',
+  and in base 10 other- wise. Only characters that correspond to the
+  base are recognized.
+
+[o]
+  Matches an optionally signed octal integer.
+
+[x,X]
+  Matches an optionally signed hexadecimal integer,
+
+[f,g,e,E]
+  Matches an optionally signed floating-point number.
+
+[s]
+  Matches a sequence of non-white-space character. The input string stops at
+  white space or at the maximum field width, whichever occurs first.
+
+[c]
+  Matches a single character, or a sequence of <em>n</em> characters if a
+  field width of <em>n</em> is specified. The usual skip of leading white
+  space is suppressed. To skip white space first, use an explicit space in
+  the format.
+
+[<tt>[</tt>]
+  Matches a nonempty sequence of characters from the specified set
+  of accepted characters.  The usual skip of leading white space is
+  suppressed.  This bracketed sub-expression is interpreted exactly like a
+  character class in a Ruby regular expression.  (In fact, it is placed as-is
+  in a regular expression.)  The matching against the input string ends with
+  the appearance of a character not in (or, with a circumflex, in) the set,
+  or when the field width runs out, whichever comes first.
+
+===Assignment suppression
+
+To require that a particular match occur, but without including the result
+in the return array, place the <b>assignment suppression flag</b>, which is
+the star character ('*'), immediately after the leading '%' of a format
+specifier (just before the field width, if any).
+
+==Examples
+
+See the files <tt>EXAMPLES</tt> and <tt>tests/scanftests.rb</tt>.
+
+==scanf for Ruby compared with scanf in C
+
+scanf for Ruby is based on the C function scanf(3), but with modifications,
+dictated mainly by the underlying differences between the languages.
+
+===Unimplemented flags and specifiers
+
+* The only flag implemented in scanf for Ruby is '<tt>*</tt>' (ignore
+  upcoming conversion). Many of the flags available in C versions of scanf(4)
+  have to do with the type of upcoming pointer arguments, and are literally
+  meaningless in Ruby.
+
+* The <tt>n</tt> specifier (store number of characters consumed so far in
+  next pointer) is not implemented.
+
+* The <tt>p</tt> specifier (match a pointer value) is not implemented.
+
+===Altered specifiers
+
+[o,u,x,X]
+  In scanf for Ruby, all of these specifiers scan for an optionally signed
+  integer, rather than for an unsigned integer like their C counterparts.
+
+===Return values
+
+scanf for Ruby returns an array of successful conversions, whereas
+scanf(3) returns the number of conversions successfully
+completed. (See below for more details on scanf for Ruby's return
+values.)
+
+==Return values
+
+Without a block, scanf returns an array containing all the conversions
+it has found. If none are found, scanf will return an empty array. An
+unsuccesful match is never ignored, but rather always signals the end
+of the scanning operation. If the first unsuccessful match takes place
+after one or more successful matches have already taken place, the
+returned array will contain the results of those successful matches.
+
+With a block scanf returns a 'map'-like array of transformations from
+the block -- that is, an array reflecting what the block did with each
+yielded result from the iterative scanf operation.  (See "Block
+usage", above.)
+
+==Test suite
+
+scanf for Ruby includes a suite of unit tests (requiring the
+<tt>TestUnit</tt> package), which can be run with the command <tt>ruby
+tests/scanftests.rb</tt> or the command <tt>make test</tt>.
+
+==Current limitations and bugs
+
+When using IO#scanf under Windows, make sure you open your files in
+binary mode:
+
+    File.open("filename", "rb")
+
+so that scanf can keep track of characters correctly.
+
+Support for character classes is reasonably complete (since it
+essentially piggy-backs on Ruby's regular expression handling of
+character classes), but users are advised that character class testing
+has not been exhaustive, and that they should exercise some caution
+in using any of the more complex and/or arcane character class
+idioms.
+
+
+==Technical notes
+
+===Rationale behind scanf for Ruby
+
+The impetus for a scanf implementation in Ruby comes chiefly from the fact
+that existing pattern matching operations, such as Regexp#match and
+String#scan, return all results as strings, which have to be converted to
+integers or floats explicitly in cases where what's ultimately wanted are
+integer or float values.
+
+===Design of scanf for Ruby
+
+scanf for Ruby is essentially a <format string>-to-<regular
+expression> converter.
+
+When scanf is called, a FormatString object is generated from the
+format string ("%d%s...") argument. The FormatString object breaks the
+format string down into atoms ("%d", "%5f", "blah", etc.), and from
+each atom it creates a FormatSpecifier object, which it
+saves.
+
+Each FormatSpecifier has a regular expression fragment and a "handler"
+associated with it. For example, the regular expression fragment
+associated with the format "%d" is "([-+]?\d+)", and the handler
+associated with it is a wrapper around String#to_i. scanf itself calls
+FormatString#match, passing in the input string. FormatString#match
+iterates through its FormatSpecifiers; for each one, it matches the
+corresponding regular expression fragment against the string. If
+there's a match, it sends the matched string to the handler associated
+with the FormatSpecifier.
+
+Thus, to follow up the "%d" example: if "123" occurs in the input
+string when a FormatSpecifier consisting of "%d" is reached, the "123"
+will be matched against "([-+]?\d+)", and the matched string will be
+rendered into an integer by a call to to_i.
+
+The rendered match is then saved to an accumulator array, and the
+input string is reduced to the post-match substring. Thus the string
+is "eaten" from the left as the FormatSpecifiers are applied in
+sequence.  (This is done to a duplicate string; the original string is
+not altered.)
+
+As soon as a regular expression fragment fails to match the string, or
+when the FormatString object runs out of FormatSpecifiers, scanning
+stops and results accumulated so far are returned in an array.
+
+==License and copyright
+
+Copyright:: (c) 2002-2003 David Alan Black
+License:: Distributed on the same licensing terms as Ruby itself
+
+==Warranty disclaimer
+
+This software is provided "as is" and without any express or implied
+warranties, including, without limitation, the implied warranties of
+merchantibility and fitness for a particular purpose.
+
+==Credits and acknowledgements
+
+scanf for Ruby was developed as the major activity of the Austin
+Ruby Codefest (Austin, Texas, August 2002).
+
+Principal author:: David Alan Black (mailto:dblack@superlink.net)
+Co-author:: Hal Fulton (mailto:hal9000@hypermetrics.com)
+Project contributors:: Nolan Darilek, Jason Johnston
+
+Thanks to Hal Fulton for hosting the Codefest.
+
+Thanks to Matz for suggestions about the class design.  
+
+Thanks to Gavin Sinclair for some feedback on the documentation.
+
+The text for parts of this document, especially the Description and
+Conversions sections, above, were adapted from the Linux Programmer's
+Manual manpage for scanf(3), dated 1995-11-01.
+
+==Bugs and bug reports
+
+scanf for Ruby is based on something of an amalgam of C scanf
+implementations and documentation, rather than on a single canonical
+description. Suggestions for features and behaviors which appear in
+other scanfs, and would be meaningful in Ruby, are welcome, as are
+reports of suspicious behaviors and/or bugs. (Please see "Credits and
+acknowledgements", above, for email addresses.)
+
+=end
+
+module Scanf
+
+  class FormatSpecifier
+
+    attr_reader :re_string, :matched_string, :conversion, :matched
+
+    private
+
+    def skip;  /^\s*%\*/.match(@spec_string); end
+
+    def extract_float(s); s.to_f if s &&! skip; end
+    def extract_decimal(s); s.to_i if s &&! skip; end
+    def extract_hex(s); s.hex if s &&! skip; end
+    def extract_octal(s); s.oct if s &&! skip; end
+    def extract_integer(s); Integer(s) if s &&! skip; end
+    def extract_plain(s); s unless skip; end
+
+    def nil_proc(s); nil; end
+
+    public
+
+    def to_s
+      @spec_string
+    end
+
+    def count_space?
+      /(?:\A|\S)%\*?\d*c|\[/.match(@spec_string)
+    end
+
+    def initialize(str)
+      @spec_string = str
+      h = '[A-Fa-f0-9]'
+
+      @re_string, @handler = 
+        case @spec_string
+
+          # %[[:...:]]
+        when /%\*?(\[\[:[a-z]+:\]\])/
+          [ "(#{$1}+)", :extract_plain ]
+
+          # %5[[:...:]]
+        when /%\*?(\d+)(\[\[:[a-z]+:\]\])/
+          [ "(#{$2}{1,#{$1}})", :extract_plain ]
+
+          # %[...]
+        when /%\*?\[([^\]]*)\]/
+          yes = $1
+          if /^\^/.match(yes) then no = yes[1..-1] else no = '^' + yes end
+          [ "([#{yes}]+)(?=[#{no}]|\\z)", :extract_plain ]
+
+          # %5[...]
+        when /%\*?(\d+)\[([^\]]*)\]/
+          yes = $2
+          w = $1
+          [ "([#{yes}]{1,#{w}})", :extract_plain ]
+
+          # %i
+        when /%\*?i/
+          [ "([-+]?(?:(?:0[0-7]+)|(?:0[Xx]#{h}+)|(?:[1-9]\\d*)))", :extract_integer ]
+
+          # %5i
+        when /%\*?(\d+)i/
+          n = $1.to_i
+          s = "("
+          if n > 1 then s += "[1-9]\\d{1,#{n-1}}|" end
+          if n > 1 then s += "0[0-7]{1,#{n-1}}|" end
+          if n > 2 then s += "[-+]0[0-7]{1,#{n-2}}|" end
+          if n > 2 then s += "[-+][1-9]\\d{1,#{n-2}}|" end
+          if n > 2 then s += "0[Xx]#{h}{1,#{n-2}}|" end
+          if n > 3 then s += "[-+]0[Xx]#{h}{1,#{n-3}}|" end
+          s += "\\d"
+          s += ")"
+          [ s, :extract_integer ]
+
+          # %d, %u
+        when /%\*?[du]/
+          [ '([-+]?\d+)', :extract_decimal ]
+
+          # %5d, %5u
+        when /%\*?(\d+)[du]/
+          n = $1.to_i
+          s = "("
+          if n > 1 then s += "[-+]\\d{1,#{n-1}}|" end
+          s += "\\d{1,#{$1}})"
+          [ s, :extract_decimal ]
+
+          # %x
+        when /%\*?[Xx]/
+          [ "([-+]?(?:0[Xx])?#{h}+)", :extract_hex ]
+
+          # %5x
+        when /%\*?(\d+)[Xx]/
+          n = $1.to_i
+          s = "("
+          if n > 3 then s += "[-+]0[Xx]#{h}{1,#{n-3}}|" end
+          if n > 2 then s += "0[Xx]#{h}{1,#{n-2}}|" end
+          if n > 1 then s += "[-+]#{h}{1,#{n-1}}|" end
+          s += "#{h}{1,#{n}}"
+          s += ")"
+          [ s, :extract_hex ]
+
+          # %o
+        when /%\*?o/
+          [ '([-+]?[0-7]+)', :extract_octal ]
+
+          # %5o
+        when /%\*?(\d+)o/
+          [ "([-+][0-7]{1,#{$1.to_i-1}}|[0-7]{1,#{$1}})", :extract_octal ]
+
+          # %f
+        when /%\*?f/
+          [ '([-+]?((\d+(?>(?=[^\d.]|$)))|(\d*(\.(\d*([eE][-+]?\d+)?)))))', :extract_float ]
+
+          # %5f
+        when /%\*?(\d+)f/
+          [ "(\\S{1,#{$1}})", :extract_float ]
+
+          # %5s
+        when /%\*?(\d+)s/
+          [ "(\\S{1,#{$1}})", :extract_plain ]
+
+          # %s
+        when /%\*?s/
+          [ '(\S+)', :extract_plain ]
+
+          # %c
+        when /\s%\*?c/
+          [ "\\s*(.)", :extract_plain ]
+
+          # %c
+        when /%\*?c/
+          [ "(.)", :extract_plain ]
+
+          # %5c (whitespace issues are handled by the count_*_space? methods)
+        when /%\*?(\d+)c/
+          [ "(.{1,#{$1}})", :extract_plain ]
+
+          # %%
+        when /%%/
+          [ '(\s*%)', :nil_proc ]
+
+          # literal characters
+        else
+          [ "(#{Regexp.escape(@spec_string)})", :nil_proc ]
+        end
+
+      @re_string = '\A' + @re_string
+    end
+
+    def to_re
+      Regexp.new(@re_string,Regexp::MULTILINE)
+    end
+
+    def match(str)
+      @matched = false
+      s = str.dup
+      s.sub!(/\A\s+/,'') unless count_space?
+      res = to_re.match(s)
+      if res
+        @conversion = send(@handler, res[1])
+        @matched_string = @conversion.to_s
+        @matched = true
+      end
+      res
+    end
+
+    def letter
+      /%\*?\d*([a-z\[])/.match(@spec_string).to_a[1]
+    end
+
+    def width
+      w = /%\*?(\d+)/.match(@spec_string).to_a[1]
+      w && w.to_i
+    end
+
+    def mid_match?
+      return false unless @matched
+      cc_no_width    = letter == '[' &&! width
+      c_or_cc_width  = (letter == 'c' || letter == '[') && width
+      width_left     = c_or_cc_width && (matched_string.size < width)
+
+      return width_left || cc_no_width
+    end
+    
+  end
+
+  class FormatString
+
+    attr_reader :string_left, :last_spec_tried,
+                :last_match_tried, :matched_count, :space
+
+    SPECIFIERS = 'diuXxofeEgsc'
+    REGEX = /
+        # possible space, followed by...
+          (?:\s*
+          # percent sign, followed by...
+            %
+            # another percent sign, or...
+              (?:%|
+        	 # optional assignment suppression flag
+        	 \*?
+        	 # optional maximum field width
+        	 \d*
+        	   # named character class, ...
+        	   (?:\[\[:\w+:\]\]|
+        	   # traditional character class, or...
+        	      \[[^\]]*\]|
+        	   # specifier letter.
+        	      [#{SPECIFIERS}])))|
+            # or miscellaneous characters
+              [^%\s]+/ix
+
+    def initialize(str)
+      @specs = []
+      @i = 1
+      s = str.to_s
+      return unless /\S/.match(s)
+      @space = true if /\s\z/.match(s)
+      @specs.replace s.scan(REGEX).map {|spec| FormatSpecifier.new(spec) }
+    end
+
+    def to_s
+      @specs.join('')
+    end
+
+    def prune(n=matched_count)
+      n.times { @specs.shift }
+    end
+
+    def spec_count
+      @specs.size
+    end
+
+    def last_spec
+      @i == spec_count - 1
+    end
+
+    def match(str)
+      accum = []
+      @string_left = str
+      @matched_count = 0
+
+      @specs.each_with_index do |spec,i|
+        @i = i
+        @last_spec_tried = spec
+        @last_match_tried = spec.match(@string_left)
+        break unless @last_match_tried
+        @matched_count += 1
+
+        accum << spec.conversion
+
+        @string_left = @last_match_tried.post_match
+        break if @string_left.empty?
+      end
+      return accum.compact
+    end
+  end
+end
+
+class IO
+
+# The trick here is doing a match where you grab one *line*
+# of input at a time.  The linebreak may or may not occur
+# at the boundary where the string matches a format specifier.
+# And if it does, some rule about whitespace may or may not
+# be in effect...
+#
+# That's why this is much more elaborate than the string
+# version.
+#
+# For each line:
+# Match succeeds (non-emptily)
+# and the last attempted spec/string sub-match succeeded:
+#
+#   could the last spec keep matching?
+#     yes: save interim results and continue (next line)
+#
+# The last attempted spec/string did not match:
+#
+# are we on the next-to-last spec in the string?
+#   yes:
+#     is fmt_string.string_left all spaces?
+#       yes: does current spec care about input space?
+#         yes: fatal failure
+#         no: save interim results and continue
+#   no: continue  [this state could be analyzed further]
+#
+#
+
+  def scanf(str,&b)
+    return block_scanf(str,&b) if b
+    return [] unless str.size > 0
+
+    start_position = pos rescue 0
+    matched_so_far = 0
+    source_buffer = ""
+    result_buffer = []
+    final_result = []
+
+    fstr = Scanf::FormatString.new(str)
+
+    loop do
+      if eof || (tty? &&! fstr.match(source_buffer))
+        final_result.concat(result_buffer)
+        break
+      end
+
+      source_buffer << gets
+
+      current_match = fstr.match(source_buffer)
+
+      spec = fstr.last_spec_tried
+
+      if spec.matched
+        if spec.mid_match?
+          result_buffer.replace(current_match)
+          next
+        end
+
+      elsif (fstr.matched_count == fstr.spec_count - 1)
+        if /\A\s*\z/.match(fstr.string_left)
+          break if spec.count_space?
+          result_buffer.replace(current_match)
+          next
+        end
+      end
+
+      final_result.concat(current_match)
+
+      matched_so_far += source_buffer.size
+      source_buffer.replace(fstr.string_left)
+      matched_so_far -= source_buffer.size
+      break if fstr.last_spec
+      fstr.prune
+    end
+    seek(start_position + matched_so_far, IO::SEEK_SET) rescue Errno::ESPIPE
+    soak_up_spaces if fstr.last_spec && fstr.space
+
+    return final_result
+  end
+
+  private
+
+  def soak_up_spaces
+    c = getc
+    ungetc(c) if c
+    until eof ||! c || /\S/.match(c.chr)
+      c = getc
+    end
+    ungetc(c) if (c && /\S/.match(c.chr))
+  end
+
+  def block_scanf(str)
+    final = []
+# Sub-ideal, since another FS gets created in scanf.
+# But used here to determine the number of specifiers.
+    fstr = Scanf::FormatString.new(str)
+    last_spec = fstr.last_spec
+    begin
+      current = scanf(str)
+      break if current.empty?
+      final.push(yield(current))
+    end until eof || fstr.last_spec_tried == last_spec
+    return final
+  end
+end
+
+class String
+
+  def scanf(fstr,&b)
+    if b
+      block_scanf(fstr,&b)
+    else
+      fs = 
+        if fstr.is_a? Scanf::FormatString
+          fstr 
+        else 
+          Scanf::FormatString.new(fstr)
+        end
+      fs.match(self)
+    end
+  end
+
+  def block_scanf(fstr,&b)
+    fs = Scanf::FormatString.new(fstr)
+    str = self.dup
+    final = []
+    begin
+      current = str.scanf(fs)
+      final.push(yield(current)) unless current.empty?
+      str = fs.string_left
+    end until current.empty? || str.empty?
+    return final
+  end
+end
+
+module Kernel
+  private
+  def scanf(fs,&b)
+    STDIN.scanf(fs,&b)
+  end
+end

data/lib/rubysl/scanf/version.rb

@@ -0,0 +1,5 @@
+module RubySL
+  module Scanf
+    VERSION = "1.0.0"
+  end
+end

data/lib/scanf.rb

@@ -0,0 +1 @@
+require "rubysl/scanf"

data/rubysl-scanf.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+require './lib/rubysl/scanf/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rubysl-scanf"
+  spec.version       = RubySL::Scanf::VERSION
+  spec.authors       = ["Brian Shirai"]
+  spec.email         = ["brixen@gmail.com"]
+  spec.description   = %q{Ruby standard library scanf.}
+  spec.summary       = %q{Ruby standard library scanf.}
+  spec.homepage      = "https://github.com/rubysl/rubysl-scanf"
+  spec.license       = "BSD"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "mspec", "~> 1.5"
+  spec.add_development_dependency "rubysl-prettyprint", "~> 1.0"
+end

data/spec/io/block_scanf_spec.rb

@@ -0,0 +1,6 @@
+require File.expand_path('../shared/block_scanf.rb', __FILE__)
+require 'scanf'
+
+describe "IO#block_scanf" do
+  it_behaves_like(:scanf_io_block_scanf, :block_scanf)
+end

data/spec/io/fixtures/date.txt

@@ -0,0 +1,4 @@
+Beethoven  1770
+Bach       1685
+Handel     1685
+

data/spec/io/fixtures/helloworld.txt

@@ -0,0 +1 @@
+hello world

data/spec/io/scanf_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path('../shared/block_scanf.rb', __FILE__)
+require 'scanf'
+
+describe "IO#scanf" do
+  before :each do
+    @hw = File.open(File.dirname(__FILE__) + '/fixtures/helloworld.txt', 'r')
+    @data = File.open(File.dirname(__FILE__) + '/fixtures/date.txt', 'r')
+  end
+
+  after :each do
+    @hw.close unless @hw.closed?
+    @data.close unless @data.closed?
+  end
+
+  it "returns an array containing the input converted in the specified type" do
+    @hw.scanf("%s%s").should == ["hello", "world"]
+    @data.scanf("%s%d").should == ["Beethoven", 1770]
+  end
+
+  it "returns an array containing the input converted in the specified type with given maximum field width" do
+    @hw.scanf("%2s").should == ["he"]
+    @data.scanf("%2c").should == ["Be"]
+  end
+
+  it "returns an empty array when a wrong specifier is passed" do
+    @hw.scanf("%a").should == []
+    @hw.scanf("%1").should == []
+    @data.scanf("abc").should == []
+  end
+end
+
+describe "IO#scanf with block" do
+  it_behaves_like(:scanf_io_block_scanf, :scanf)
+end

data/spec/io/shared/block_scanf.rb

@@ -0,0 +1,28 @@
+require 'scanf'
+
+describe :scanf_io_block_scanf, :shared => true do
+  before :each do
+    @data= File.open(File.dirname(__FILE__) + '/../fixtures/date.txt', 'r')
+  end
+
+  after :each do
+    @data.close unless @data.closed?
+  end
+
+  it "passes each match to the block as an array" do
+    res = @data.send(@method, "%s%d") { |name, year| "#{name} was born in #{year}." }
+    res.should == ["Beethoven was born in 1770.", "Bach was born in 1685.", "Handel was born in 1685."]
+  end
+
+  it "keeps scanning the input and cycling back to the beginning of the input string" do
+    a = []
+    @data.send(@method, "%s"){|w| a << w}
+    a.should == [["Beethoven"], ["1770"], ["Bach"], ["1685"], ["Handel"], ["1685"]]
+  end
+
+  it "returns an empty array when a wrong specifier is passed" do
+    a = []
+    @data.send(@method, "%z"){|w| a << w}
+    a.empty?.should be_true
+  end
+end

data/spec/string/block_scanf_spec.rb

@@ -0,0 +1,6 @@
+require File.expand_path('../shared/block_scanf.rb', __FILE__)
+require 'scanf'
+
+describe "String#block_scanf" do
+  it_behaves_like(:scanf_string_block_scanf, :block_scanf)
+end

data/spec/string/scanf_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path('../shared/block_scanf.rb', __FILE__)
+require 'scanf'
+
+describe "String#scanf" do
+  it "returns an array containing the input converted in the specified type" do
+    "hello world".scanf("%s").should == ["hello"]
+    "hello world".scanf("%s%d").should == ["hello"]
+    "hello world".scanf("%s%c").should == ["hello", " "]
+    "hello world".scanf("%c%s").should == ["h", "ello"]
+    "hello world".scanf("%s%s").should == ["hello", "world"]
+    "hello world".scanf("%c").should == ["h"]
+    "123".scanf("%s").should == ["123"]
+    "123".scanf("%c").should == ["1"]
+    "123".scanf("%d").should == [123]
+    "123".scanf("%u").should == [123]
+    "123".scanf("%o").should == [83]
+    "123".scanf("%x").should == [291]
+    "123".scanf("%i").should == [123]
+    "0123".scanf("%i").should == [83]
+    "123".scanf("%f").should == [123.0]
+    "0X123".scanf("%i").should == [291]
+    "0x123".scanf("%i").should == [291]
+  end
+
+  it "returns an array containing the input converted in the specified type with given maximum field width" do
+    "hello world".scanf("%2s").should == ["he"]
+    "hello world".scanf("%2c").should == ["he"]
+    "123".scanf("%2s").should == ["12"]
+    "123".scanf("%2c").should == ["12"]
+    "123".scanf("%2d").should == [12]
+    "123".scanf("%2u").should == [12]
+    "123".scanf("%2o").should == [10]
+    "123".scanf("%2x").should == [18]
+    "123".scanf("%2i").should == [12]
+    "0123".scanf("%2i").should == [1]
+    "123".scanf("%2f").should == [12.0]
+    "0X123".scanf("%2i").should == [0]
+    "0X123".scanf("%3i").should == [1]
+    "0X123".scanf("%4i").should == [18]
+  end
+
+  it "returns an empty array when a wrong specifier is passed" do
+    "hello world".scanf("%a").should == []
+    "123".scanf("%1").should == []
+    "123".scanf("abc").should == []
+    "123".scanf(:d).should == []
+  end
+end
+
+describe "String#scanf with block" do
+  it_behaves_like(:scanf_string_block_scanf, :scanf)
+end

data/spec/string/shared/block_scanf.rb

@@ -0,0 +1,26 @@
+require 'scanf'
+
+describe :scanf_string_block_scanf, :shared => true do
+  it "passes each match to the block as an array" do
+    a = []
+    "hello world".send(@method, "%s%s"){|w| a << w}
+    a.should == [["hello", "world"]]
+  end
+
+  it "keeps scanning the input and cycling back to the beginning of the input string" do
+    a = []
+    "hello world".send(@method, "%s"){|w| a << w}
+    a.should == [["hello"], ["world"]]
+
+    s = []
+    str = "123 abc 456 def 789 ghi"
+    s = str.send(@method, "%d%s"){|num,str| [num * 2, str.upcase]}
+    s.should == [[246, "ABC"], [912, "DEF"], [1578, "GHI"]]
+  end
+
+  it "returns an empty array when a wrong specifier is passed" do
+    a = []
+    "hello world".send(@method, "%z"){|w| a << w}
+    a.empty?.should be_true
+  end
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: rubysl-scanf
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Brian Shirai
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: mspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rubysl-prettyprint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Ruby standard library scanf.
+email:
+- brixen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/rubysl/scanf.rb
+- lib/rubysl/scanf/scanf.rb
+- lib/rubysl/scanf/version.rb
+- lib/scanf.rb
+- rubysl-scanf.gemspec
+- spec/io/block_scanf_spec.rb
+- spec/io/fixtures/date.txt
+- spec/io/fixtures/helloworld.txt
+- spec/io/scanf_spec.rb
+- spec/io/shared/block_scanf.rb
+- spec/string/block_scanf_spec.rb
+- spec/string/scanf_spec.rb
+- spec/string/shared/block_scanf.rb
+homepage: https://github.com/rubysl/rubysl-scanf
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.7
+signing_key: 
+specification_version: 4
+summary: Ruby standard library scanf.
+test_files:
+- spec/io/block_scanf_spec.rb
+- spec/io/fixtures/date.txt
+- spec/io/fixtures/helloworld.txt
+- spec/io/scanf_spec.rb
+- spec/io/shared/block_scanf.rb
+- spec/string/block_scanf_spec.rb
+- spec/string/scanf_spec.rb
+- spec/string/shared/block_scanf.rb