rhetor 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3f2702dc837acf720a37f663d219b2c3b59a13dc
+  data.tar.gz: 5fa1338de3e9f990594c8fa411e5eb24cfe07569
+SHA512:
+  metadata.gz: a93d30c92bbb94a8805bf01d310077512535388d5df106b7bf678c5e220687668db307a442a19e2678acd68f7a4ceedcf826fd1aaf3bb86ff872f21bd6ca1e5a
+  data.tar.gz: a6d0a3b06821db3a832098e9759d1b6366b9eb4253ed70992da035ab9ec9a0443865ed3926debe342aad061cb81504721942e5a05bd8ca7d7062a98be1ce7df0

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+/.idea/

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--warnings
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,5 @@
+require: rubocop-rspec
+Style/Documentation:
+  Enabled: false
+Style/AccessorMethodName:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - "1.9.3"
+  - "2.2.0"

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Change log
+
+## master (unreleased)
+
+## 0.1.0 (2015-01-06)
+
+### New features
+
+* You can provide a block for LexicalAnalyser#analyse method and it will be run with each of encountered tokens.
+* Tokens have values instead of corresponding substrings. You can provide an evaluator for any rule. It is a block that will be called if the pattern is encountered. It should receive a matched substring and return the value of the corresponding token. If the evaluator is omitted, the value of the token will coincide with the matched substring.
+* Tokens can be represented as a string via to_s method
+
+### Changes
+
+* Update example in README.md
+
+### Bugs fixed
+
+* Fix Rake task `test:coverage'

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'coveralls', require: false
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Egor Dubenetskiy
+
+MIT License
+
+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.md

@@ -0,0 +1,102 @@
+# Rhetor
+
+[![GitHub](https://img.shields.io/badge/github-edubenetskiy/rhetor-blue.svg)](https://github.com/edubenetskiy/rhetor)
+[![RubyGems.org](https://img.shields.io/badge/gem-rhetor-blue.svg)](https://www.rubygems.org/gems/rhetor)
+[![Documentation](https://img.shields.io/badge/docs-rdoc.info-blue.svg)](http://www.rubydoc.info/gems/rhetor/frames)
+[![License](https://img.shields.io/packagist/l/doctrine/orm.svg)](#license)
+
+[![Dependency Status](https://gemnasium.com/edubenetskiy/rhetor.svg)](https://gemnasium.com/edubenetskiy/rhetor)
+[![Coverage Status](https://img.shields.io/coveralls/edubenetskiy/rhetor.svg)](https://coveralls.io/r/edubenetskiy/rhetor?branch=master)
+[![Build Status](https://api.travis-ci.org/edubenetskiy/rhetor.svg?branch=master)](https://travis-ci.org/edubenetskiy/rhetor)
+[![Code Climate](https://codeclimate.com/github/edubenetskiy/rhetor/badges/gpa.svg)](https://codeclimate.com/github/edubenetskiy/rhetor)
+[![Gem Version](https://badge.fury.io/rb/rhetor.svg)](https://github.com/edubenetskiy/rhetor/releases)
+
+
+Rhetor is yet another lexical analyser library written in pure Ruby
+with no runtime dependencies. It is properly documented and easy-to-use.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rhetor'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rhetor
+
+## Usage
+
+```ruby
+# Define behaviour
+lexer = Rhetor::LexicalAnalyser.new do
+  # Within this block you can define your own rules, your own patterns
+  # to recognize. You can call these methods out of this block
+  # like this: lexer.rule(...), it also works.
+  rule '+', :plus
+  rule '-', :minus
+  rule '*', :asterisk
+  rule '/', :solidus
+  rule '(', :left_parenthesis
+  rule ')', :right_parenthesis
+
+  # This rule will return tokens with floating-point values.
+  # Actually, you can make Rhetor to return tokens with any types of values,
+  # you only have to provide an evaluator - a block which receives a matched
+  # substring and returns the desired value. Like here:
+  rule(/[-+]?[0-9]*\.?[0-9]+/, :number) { |string| string.to_f }
+
+  # Here we make Rhetor to ignore whitespaces via the regular expression:
+  ignore(/\s+/)
+  # We could also do it with a string: ignore ' ',
+  # but regular expressions are more powerful.
+end
+
+# Analyse method returns an array of tokens. You can provide a block
+# and it will be run for each of encountered tokens.
+tokens = lexer.analyse('2 + 2 * 2 - (25 / (3 + 70 / 4))') do |token|
+  puts token
+end
+# It produces:
+# (number: 2.0 [0,1])
+# (plus: "+" [2,1])
+# (number: 2.0 [4,1])
+# (asterisk: "*" [6,1])
+# (number: 2.0 [8,1])
+# (minus: "-" [10,1])
+# (left_parenthesis: "(" [12,1])
+# (number: 25.0 [13,2])
+# (solidus: "/" [16,1])
+# (left_parenthesis: "(" [18,1])
+# (number: 3.0 [19,1])
+# (plus: "+" [21,1])
+# (number: 70.0 [23,2])
+# (solidus: "/" [26,1])
+# (number: 4.0 [28,1])
+# (right_parenthesis: ")" [29,1])
+# (right_parenthesis: ")" [30,1])
+
+# Now get information about any of the tokens:
+token = tokens.first # => (number: 2.0 [0,1])
+token.value          # => 2.0
+token.name           # => :number
+token.position       # => 0
+token.length         # => 1
+```
+
+## Contributing
+
+1. Fork it (https://github.com/edubenetskiy/rhetor)
+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 a new Pull Request
+
+## License
+Rhetor © 2015 by Egor Dubenetskiy. Rhetor is licensed under the MIT license. Please see LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler/gem_tasks'
+require 'yard'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+require 'inch/rake'
+
+Inch::Rake::Suggest.new
+YARD::Rake::YardocTask.new
+RuboCop::RakeTask.new
+RSpec::Core::RakeTask.new('spec')
+
+task default: %w(spec rubocop)

data/lib/rhetor.rb

@@ -0,0 +1,6 @@
+require 'rhetor/version'
+require 'rhetor/lexical_analyser'
+
+# The primary module of the gem
+module Rhetor
+end

data/lib/rhetor/exceptions.rb

@@ -0,0 +1,9 @@
+module Rhetor
+  RhetorError = Class.new(StandardError)
+  UnmatchedString = Class.new(RhetorError)
+  InvalidRuleName = Class.new(RhetorError)
+  RuleAlreadyExists = Class.new(RhetorError)
+  InvalidPattern = Class.new(RhetorError)
+  InvalidString = Class.new(RhetorError)
+  NoStringLoaded = Class.new(RhetorError)
+end

data/lib/rhetor/lexical_analyser.rb

@@ -0,0 +1,158 @@
+require 'rhetor/exceptions'
+require 'rhetor/token'
+
+module Rhetor
+  # LexicalAnalyser is a class that performs lexical analysis
+  # of strings using a set of predefined rules.
+  #
+  # @!attribute [r] string
+  #   @return [String] the string being analyzed
+  # @!attribute [r] position
+  #   @return [Integer] the current position of analyser
+  #
+  # @author Egor Dubenetskiy <edubenetskiy@ya.ru>
+  #
+  class LexicalAnalyser
+    attr_reader :string, :position
+
+    # Creates a new lexical analyser and evaluates the passed block within it
+    # @param block [Block] the block to be executed
+    # @example Creating a simple HQ9+ parser
+    #   lexer = Rhetor::LexicalAnalyser.new {
+    #     rule 'H', :hello_world
+    #     rule 'Q', :quine
+    #     rule '9', :ninety_nine_bottles
+    #     rule '+', :increment
+    #     ignore /\s+/
+    #   }
+    # @return [void]
+    #
+    def initialize(&block)
+      @string_patterns = {}
+      @regexp_patterns = {}
+      @ignored = []
+      @used_names = []
+      @evaluator = {}
+      @string = nil
+      @position = nil
+      (block.arity == 1) ? block[self] : instance_eval(&block) if block_given?
+    end
+
+    # Makes the analyser to recognize some pattern
+    # @param pattern [String, Regexp] the pattern
+    # @param name [Symbol] the name of the rule
+    # @param evaluator [Proc,nil] a proc. This proc will be called
+    #   if the pattern is encountered. It receives a matched substring
+    #   and calculates the value of the corresponding token. If this
+    #   argument is omitted, the value of the token will coincide
+    #   with the matched substring.
+    # @raise [InvalidPattern] if the pattern is not valid
+    # @raise [InvalidRuleName] unless the name of the rule is a symbol
+    # @raise [RuleAlreadyExists] if the rule with the same name already exists
+    # @return [void]
+    #
+    def rule(pattern, name, &evaluator)
+      check_rule(pattern, name)
+      @used_names.push name
+      @evaluator[name] = evaluator
+      array_name = "@#{pattern.class.name.downcase}_patterns".intern
+      instance_variable_get(array_name)[name] = pattern
+    end
+
+    # Makes the analyser to ignore some pattern
+    # @param pattern [String, Regexp] the pattern to be ignored
+    # @return [void]
+    #
+    def ignore(pattern)
+      fail InvalidPattern unless [String, Regexp].include? pattern.class
+      @ignored.push pattern unless @ignored.include? pattern
+    end
+
+    # Initiates the analysis of the string
+    # @param string [String] the string to be analyzed
+    # @return [void]
+    #
+    def begin_analysis(string)
+      fail InvalidString unless string.is_a? String
+      @string = string
+      @position = 0
+      @size = string.size
+    end
+
+    # @return [Token] the next token found in the string
+    # @raise [NoStringLoaded] if no string is being analyzed
+    # @raise [UnmatchedString] if the analyser is unable to get the next token
+    #
+    def next_token
+      fail NoStringLoaded unless @string
+      @position = skip_ignored(@string, @position)
+      return EOF_TOKEN if @position >= @size
+      name, length = string_pattern(@string, @position)
+      name, length = regexp_pattern(@string, @position) if length == 0
+      fail UnmatchedString, "at position #{@position}" if length == 0
+      token = make_token(name, @position, length)
+      @position += length
+      token
+    end
+
+    # Analyzes the given string
+    # @param string [String] the string to be analyzed
+    # @yieldparam token [Token] every encountered token
+    # @return [Array<Token>] the array of encountered tokens
+    #
+    def analyse(string, &block)
+      begin_analysis(string)
+      tokens = []
+      loop do
+        last_token = next_token
+        (last_token == EOF_TOKEN) ? break : tokens << last_token
+        block.call(last_token) if block_given?
+      end
+      tokens
+    end
+
+    private
+
+    def make_token(name, position, size)
+      substring = @string[position, size]
+      value = @evaluator[name] ? @evaluator[name].call(substring) : substring
+      Rhetor::Token.new(value, name, position, size)
+    end
+
+    def check_rule(pattern, name)
+      fail InvalidPattern unless [String, Regexp].include? pattern.class
+      fail InvalidRuleName unless name.is_a? Symbol
+      fail RuleAlreadyExists if @used_names.include? name
+    end
+
+    def string_pattern(string, position)
+      results = @string_patterns.map do |name, pattern|
+        [name, matched_size(pattern, string, position)]
+      end
+      results.max_by(&:last) || [nil, 0]
+    end
+
+    def regexp_pattern(string, position)
+      results = @regexp_patterns.map do |name, pattern|
+        [name, matched_size(pattern, string, position)]
+      end
+      # results.max_by(&:last) || [nil, 0]
+      results.sort_by(&:last).find { |_name, size| size > 0 } || [nil, 0]
+    end
+
+    def skip_ignored(string, position)
+      skipped = @ignored.map { |p| matched_size(p, string, position) }.max
+      skipped ? position + skipped : position
+    end
+
+    def matched_size(pattern, string, position)
+      if pattern.is_a? String
+        (string[position, pattern.size] == pattern) ? pattern.size : 0
+      elsif pattern.is_a? Regexp
+        md = string.match(pattern, position)
+        return 0 unless md
+        md.begin(0) == position ? md[0].size : 0
+      end
+    end
+  end
+end

data/lib/rhetor/token.rb

@@ -0,0 +1,18 @@
+module Rhetor
+  # Token class represents tokens matched from the input.
+  #
+  # @attr_reader [Object] value the value of the token
+  # @attr_reader [Symbol] name the name of the matched rule
+  # @attr_reader [Integer] position the position of the matched substring
+  # @attr_reader [Integer] length the length of the matched substring
+  #
+  Token = Struct.new :value, :name, :position, :length do
+    def to_s
+      "(#{name}: #{value.inspect} [#{position},#{length}])"
+    end
+
+    alias_method :inspect, :to_s
+  end
+
+  EOF_TOKEN = Token.new(nil, nil, -1, nil)
+end

data/lib/rhetor/version.rb

@@ -0,0 +1,3 @@
+module Rhetor
+  VERSION = '0.2.0'
+end

data/rhetor.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rhetor/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'rhetor'
+  spec.version = Rhetor::VERSION
+  spec.authors = ['Egor Dubenetskiy']
+  spec.email = ['edubenetskiy@ya.ru']
+  spec.summary = 'Rhetor is yet another lexical analyser written in Ruby'
+  spec.description = 'Rhetor is yet another lexical analyser library
+                        written in pure Ruby with no runtime dependencies,
+                        properly documented and easy-to-use.'
+  spec.homepage = 'https://github.com/edubenetskiy/rhetor/'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 1.9.3'
+
+  spec.files = `git ls-files -z`.split("\x0")
+  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.7'
+  spec.add_development_dependency 'rake', '~> 10.4'
+  spec.add_development_dependency 'simplecov', '~> 0.9'
+  spec.add_development_dependency 'rspec', '~> 3.1'
+  spec.add_development_dependency 'rubocop', '~> 0.28'
+  spec.add_development_dependency 'rubocop-rspec', '~> 1.2'
+  spec.add_development_dependency 'inch', '~> 0.5'
+  spec.add_development_dependency 'yard', '~> 0.8'
+end

data/spec/lexical_analyser_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Rhetor do
+  describe LexicalAnalyser do
+    subject('analyser') do
+      described_class.new do |t|
+        t.rule 'key', :key
+        t.rule 'keyword', :keyword
+        t.rule 'word', :word
+      end
+    end
+
+    it 'returns an empty array being called with an empty string' do
+      expect(analyser.analyse '').to eq []
+    end
+
+    it 'returns an empty array if ignores anything' do
+      analyser.ignore(/.+/)
+      expect(analyser.analyse 'something anything').to eq []
+    end
+
+    it 'does not recognize an improper string' do
+      expect { analyser.analyse 'something' }.to raise_error(UnmatchedString)
+    end
+
+    it 'recognizes a single keyword' do
+      expect(analyser.analyse 'word').to eq [Token.new('word', :word, 0, 4)]
+      expect(analyser.analyse 'key').to eq [Token.new('key', :key, 0, 3)]
+    end
+
+    it 'recognizes a single pattern' do
+      analyser.rule(/\w+/, :custom_word)
+      expect(analyser.analyse 'something').to eq \
+        [Token.new('something', :custom_word, 0, 9)]
+    end
+
+    it 'recognizes a sequence of patterns and keywords' do
+      analyser.rule(/\w+/, :custom_word)
+      analyser.ignore(/\s+/)
+      expect(analyser.analyse 'some word').to eq \
+        [Token.new('some', :custom_word, 0, 4),
+         Token.new('word', :word, 5, 4)]
+    end
+
+    it 'takes only the longest token of several overlapped tokens' do
+      expect(analyser.analyse 'keyword').to eq \
+        [Token.new('keyword', :keyword, 0, 7)]
+    end
+
+    it 'recognizes several consecutive keywords' do
+      expect(analyser.analyse 'wordkeykeyword').to eq \
+        [Token.new('word', :word, 0, 4),
+         Token.new('key', :key, 4, 3),
+         Token.new('keyword', :keyword, 7, 7)]
+    end
+
+    it 'forbids the creation of rules with identical names' do
+      expect do
+        analyser.rule('key', :key)
+      end.to raise_error(RuleAlreadyExists)
+    end
+
+    it 'checks the validity of the names of the rules' do
+      expect do
+        analyser.rule('something', 'invalid rule name')
+      end.to raise_error(InvalidRuleName)
+    end
+
+    it 'checks the validity of the pattern' do
+      expect do
+        analyser.rule(:invalid_rule_pattern, :invalid_rule)
+      end.to raise_error(InvalidPattern)
+    end
+
+    it 'skips specified patterns' do
+      analyser.ignore(/\s+/)
+      expect(analyser.analyse 'word key keyword').to eq \
+        [Token.new('word', :word, 0, 4),
+         Token.new('key', :key, 5, 3),
+         Token.new('keyword', :keyword, 9, 7)]
+    end
+
+    it 'executes a passed block' do
+      expect do |b|
+        analyser.analyse('wordkeykeyword', &b)
+      end.to yield_successive_args(Token.new('word', :word, 0, 4),
+                                   Token.new('key', :key, 4, 3),
+                                   Token.new('keyword', :keyword, 7, 7))
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+# Coverage support needs to be required *before* the Rhetor code is required!
+require 'support/coverage'
+require 'rhetor'
+include Rhetor
+
+RSpec.configure do |_config|
+end

data/spec/support/coverage.rb

@@ -0,0 +1,11 @@
+if ENV['TRAVIS'] || ENV['COVERAGE']
+  require 'simplecov'
+  if ENV['TRAVIS']
+    require 'coveralls'
+    SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+  end
+  SimpleCov.start do
+    add_filter '/spec/'
+    add_filter '/vendor/bundle/'
+  end
+end

data/spec/token_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Rhetor do
+  describe Token do
+    describe '#to_s' do
+      it 'returns a string representation of the token' do
+        expect(
+          Token.new('value', :name, 0, 42).to_s
+        ).to eq '(name: "value" [0,42])'
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,182 @@
+--- !ruby/object:Gem::Specification
+name: rhetor
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Egor Dubenetskiy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-09-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.28'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.28'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: inch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: |-
+  Rhetor is yet another lexical analyser library
+                          written in pure Ruby with no runtime dependencies,
+                          properly documented and easy-to-use.
+email:
+- edubenetskiy@ya.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rhetor.rb
+- lib/rhetor/exceptions.rb
+- lib/rhetor/lexical_analyser.rb
+- lib/rhetor/token.rb
+- lib/rhetor/version.rb
+- rhetor.gemspec
+- spec/lexical_analyser_spec.rb
+- spec/spec_helper.rb
+- spec/support/coverage.rb
+- spec/token_spec.rb
+homepage: https://github.com/edubenetskiy/rhetor/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Rhetor is yet another lexical analyser written in Ruby
+test_files:
+- spec/lexical_analyser_spec.rb
+- spec/spec_helper.rb
+- spec/support/coverage.rb
+- spec/token_spec.rb