parby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 86b9b440a1902cfc0bf63e95b212df61f2cd6844
+  data.tar.gz: 1a619e1eb0903d69a64d7db910d544ca82826370
+SHA512:
+  metadata.gz: 4dde60b0aa97baa80b0536bc73cbd77c11fb2d195a5d3042c51bc3895192102a184c15c60ff8e9849c54287d6625f3324e2cebd9c336cf1fee36efcac8617d88
+  data.tar.gz: 12347688dc2b62840c14d25bfe3759df98bd3d80da46fd58f43ba84ede40adfff3dec6ccc64fd97c1213eb16876c19d367fe0cd7517a4fa40c8b249c870cf289

data/lib/combinators.rb

@@ -0,0 +1,86 @@
+require 'parser'
+
+module Parby
+  # Always yields the value passed to it, no matter the input
+  def of(value)
+    Parser.new { |input, index| Success.new(index, value, input) }
+  end
+
+  # Yields the first character that matches predicate, it fails with the given message, otherwise a generic one
+  def test(predicate, description = nil)
+    Parser.new do |input, index|
+      found = nil
+      input.split('').each do |character|
+        if predicate.call(character)
+          found = character
+          break
+        end
+      end
+
+      if found
+        Success.new(index, found, input)
+      else
+        Failure.new(index, [description || 'Matching a predicate'], input)
+      end
+    end
+  end
+
+  # Yields the input, if it matches the regex passed to it
+  def regexp(regex)
+    # We have to match from the beginning
+    real_regex = /^#{regex}/
+
+    Parser.new do |input, index|
+      match_data = real_regex.match(input)
+
+      if match_data.nil?
+        # We did not even match one letter
+        Failure.new(index, [regex], input)
+      else
+        Success.new(index, match_data[0], input)
+      end
+    end
+  end
+
+  # Searches in the input for one of the given characters (characters can be either a string or an array), and yields it
+  def one_of(characters)
+    expected = if characters.is_a?(Array) then characters else characters.split('') end
+    test(Proc.new { |c| expected.include?(c) }, expected)
+  end
+
+  def none_of(characters)
+    test(Proc.new { |c| !characters.include?(c) }, ["None of #{characters}"])
+  end
+
+  def string(str)
+    Parser.new do |input, index|
+      furthest = -1
+
+      str.split('').each_with_index do |expected_character, expected_index|
+        actual_character = input[expected_index]
+
+        if actual_character.nil?
+          # This means that the input is smaller than the expected string
+          furthest = expected_index - 1
+          break
+        elsif actual_character != expected_character
+          # This means the input does not match exactly the string
+          furthest = expected_index
+          break
+        end
+      end
+
+      if furthest == -1
+        Success.new(index, str)
+      else
+        Failure.new(furthest, [str])
+      end
+    end
+  end
+
+  def all
+    Parser.new do |input, index|
+      Success.new(index, input, nil)
+    end
+  end
+end

data/lib/parser.rb

@@ -0,0 +1,70 @@
+module Parby
+  class Parser
+    # { |input, index| } -> result or { |input| } -> result
+    def initialize(&block)
+      raise(ArgumentError, 'A bare parser must be initialized with a 1 or 2 argument block') unless block_given?
+
+      @block = block
+    end
+
+    def parse(*args)
+      if args.length == 1
+        @block.call(args[0], 0)
+      else
+        @block.call(args[0], args[1])
+      end
+    end
+
+    def or(another_parser)
+      Parser.new do |input, index|
+        first = parse(input, index)
+
+        if first.failed?
+          another_parser.parse(input, index)
+        else
+          first
+        end
+      end
+    end
+
+    def |(other)
+      self.or other
+    end
+
+    def and(another_parser)
+      Parser.new do |input, index|
+        first = parse(input, index)
+
+        if first.failed?
+          first
+        else
+          another_parser.parse(first.remaining, first.index)
+        end
+      end
+    end
+
+    def >>(other)
+      self.and other
+    end
+
+    def fmap(&block)
+      Parser.new do |input, index|
+        result = parse(input, index)
+
+        if result.succeed?
+          result.value = yield(result.value)
+        end
+
+        result
+      end
+    end
+
+    def map(&block)
+      fmap(&block)
+    end
+
+    def consuming
+      self >> all
+    end
+  end
+end

data/lib/result.rb

@@ -0,0 +1,28 @@
+module Parby
+  Result = Struct.new('Result', :status, :index, :value, :furthest, :expected, :remaining) do
+    def failed?
+      !status
+    end
+
+    def succeed?
+      status
+    end
+
+    def completed?
+      remaining.nil?
+    end
+  end
+
+  class Success < Result
+    def initialize(index, value, remaining = nil)
+      super(true, index, value, -1, [], remaining)
+    end
+  end
+
+  class Failure < Result
+    def initialize(furthest, expected, remaining = nil)
+      actual_expected = if expected.is_a?(Array) then expected else [expected] end
+      super(false, -1, nil, furthest, actual_expected, remaining)
+    end
+  end
+end

data/spec/combinators_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+describe Parby, '#of' do
+  describe '#of' do
+    parser = Parby.of(2)
+
+    it 'Always succeeds' do
+      first_result = parser.parse('something')
+      second_result = parser.parse('another one')
+
+      expect(first_result.value).to eq(second_result.value)
+      expect(first_result).to eq(Success.new(0, 2, 'something'))
+    end
+  end
+
+  describe '#regexp' do
+    parser = Parby.regexp(/[0-9]0+/)
+
+    it 'searches for a match in the input string, yields it' do
+      result = parser.parse('100j')
+
+      expect(result.succeed?).to be true
+      expect(result.completed?).to be false
+      expect(result.remaining).to eq('100j')
+
+      expect(result.value).to eq('100')
+    end
+
+    it 'fails when it does not match a regex from the start' do
+      result = parser.parse('j100')
+
+      expect(result.succeed?).to be false
+      expect(result.completed?).to be false
+
+      expect(result.expected).to eq([/[0-9]0+/])
+    end
+  end
+
+  describe '#test' do
+    context 'given a predicate' do
+      parser = Parby.test(Proc.new { |c| c.between?('a', 'z') }, 'Alphanumeric character') # This is how Parby#between is implemented
+
+      context 'applies the predicate to each character in input' do
+        context 'if it matches in the first character' do
+          matches_first = parser.parse 'airplane'
+
+          it 'yields and does not consume the input' do
+            expect(matches_first.succeed?).to be true
+            expect(matches_first.completed?).to be false
+            expect(matches_first.value).to eq 'a'
+            expect(matches_first.remaining).to eq 'airplane'
+          end
+        end
+
+        context 'if it matches in the middle of the string' do
+          matches_in_the_middle = parser.parse '_eval'
+
+          it 'yields and does not consume the input' do
+            expect(matches_in_the_middle.succeed?).to be true
+            expect(matches_in_the_middle.completed?).to be false
+            expect(matches_in_the_middle.value).to eq 'e'
+            expect(matches_in_the_middle.remaining).to eq '_eval'
+          end
+        end
+
+        context 'if it does not match' do
+          does_not_match = parser. parse '>>='
+
+          it 'fails with the given message and does not consume the input' do
+            expect(does_not_match.failed?).to be true
+            expect(does_not_match.expected).to eq ['Alphanumeric character']
+            expect(does_not_match.remaining).to eq '>>='
+          end
+        end
+      end
+    end
+  end
+
+  describe '#one_of' do
+    parser = Parby.one_of('123')
+
+    it 'looks for exactly one character from the given string, and yields that character' do
+      result = parser.parse('jmvbn2')
+
+      expect(result.succeed?).to be true
+      expect(result.remaining).to eq('jmvbn2')
+
+      expect(result.value).to eq('2')
+    end
+
+    it 'short circuits' do
+      result = parser.parse('123')
+
+      expect(result.succeed?).to be true
+      expect(result.remaining).to eq('123')
+
+      expect(result.value).to eq('1')
+    end
+  end
+
+  describe '#none_of' do
+    parser = Parby.none_of '123'
+
+    it 'succeeds when it founds a character not in the string, and yields it' do
+      result = parser.parse '1kl'
+
+      expect(result.succeed?).to be true
+      expect(result.value).to eq 'k'
+      expect(result.remaining).to eq '1kl'
+    end
+  end
+
+  describe '#string' do
+    parser = Parby.string('Hi!')
+
+    it 'matches whole string and consumes it' do
+      result = parser.parse 'Hi!'
+
+      expect(result.succeed?).to be true
+      expect(result.value).to eq 'Hi!'
+    end
+
+    it 'Fails gracefully: says the piece of the string that it matched' do
+      result = parser.parse 'Hi'
+
+      expect(result.failed?).to be true
+      expect(result.expected).to eq ['Hi!']
+      expect(result.furthest).to eq 1
+    end
+  end
+
+  describe '#all' do
+    it 'consumes the whole input, and yields it' do
+      result = Parby.all.parse 42
+
+      expect(result.succeed?).to be true
+      expect(result.completed?).to be true
+      expect(result.value).to eq 42
+    end
+  end
+end

data/spec/parser_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper.rb'
+
+describe Parser do
+  include Parby
+
+  describe '#initialize' do
+    context 'not passing a block' do
+      it 'raises' do
+        expect {
+          Parser.new(42)
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'passing a block' do
+      it 'initializes fine' do
+        parser = Parser.new { |x| x }
+
+        expect(parser).to be_a(Parser)
+      end
+    end
+  end
+
+  describe '#parse' do
+    it 'just calls the proc' do
+      parser = Parser.new { |_, _| 'Hello' }
+
+      expect(parser.parse('some text')).to eq('Hello')
+    end
+  end
+
+  describe '#or' do
+    context 'Given two parsers' do
+      parser = Parby.regexp(/42/) | Parby.of(42)
+
+      it 'When the first one succeeds it yields, not calling the second one' do
+        result = parser.parse('42')
+
+        expect(result.succeed?).to be true
+        expect(result.value).to eq('42')
+      end
+
+      it 'When the first one succeeds it calls the second one' do
+        result = parser.parse('lol')
+
+        expect(result.succeed?).to be true
+        expect(result.value).to eq(42)
+      end
+    end
+  end
+
+  describe '#and' do
+    context 'Given two parsers' do
+      first_parser = Parby.regexp(/0/)
+
+      it 'Both should have to match to succeed, but only the second value is yielded' do
+        second_parser = Parby.regexp(/[0-9]+/)
+        parser = first_parser >> second_parser
+
+        result = parser.parse('00')
+
+        expect(result.succeed?).to be true
+        expect(result.value).to eq('00')
+      end
+
+      it 'When the first one fails, the other one is not called' do
+        second_parser = spy(Parby.regexp(/[0-9]+/))
+        parser = first_parser >> second_parser
+
+        result = parser.parse('lol')
+
+        expect(result.failed?).to be true
+        expect(second_parser).to_not have_received(:parse)
+      end
+    end
+  end
+
+  describe '#map' do
+    context 'Given a parser mapped with a mapping block' do
+      first_parser = Parser.regexp(/42/)
+      parser = first_parser.map(&:to_i)
+
+      it 'when the parser yields, it will apply the block to the resulting value' do
+        result = parser.parse('42')
+
+        expect(result.succeed?).to be true
+        expect(result.value).to eq(42)
+      end
+
+      # We still have to test for not calling the mapper function when the parser fails, but I can't mock the block :(
+    end
+  end
+
+  describe '#consuming' do
+    context 'Given a non-consuming parser' do
+      parser = regexp(/42/)
+      input = '42'
+      non_consuming_result = parser.parse input
+
+      it 'Converts it into a consuming one' do
+        consuming_result = parser.consuming.parse input
+
+        expect(consuming_result.succeed?).to be(non_consuming_result.succeed?)
+        expect(consuming_result.value).to eq(non_consuming_result.value)
+        expect(non_consuming_result.completed?).not_to be true
+        expect(consuming_result.completed?).to be true
+      end
+    end
+  end
+end

data/spec/result_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper.rb'
+
+describe Result do
+  context 'did fail' do
+    result = Failure.new(10, ['stuff'])
+
+    it 'when the status is false' do
+      expect(result.failed?).to be true
+      expect(result.succeed?).to be false
+    end
+  end
+
+  context 'did succeed' do
+    result = Success.new(1, nil)
+
+    it 'when the status is true' do
+      expect(result.failed?).to be false
+      expect(result.succeed?).to be true
+    end
+  end
+
+  context 'did complete' do
+    success = Success.new(nil, nil, 'x')
+    failure = Success.new(nil, [], 'x')
+
+    it 'when there is still input to be consumed, and does not matter if it succeeded or not' do
+      expect(success.completed?).to be false
+      expect(failure.completed?).to be false
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,54 @@
+require './lib/combinators.rb'
+require './lib/parser.rb'
+require './lib/result.rb'
+
+include RSpec
+include Parby
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: parby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rodrigo Martin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-02-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email: rodrigoleonardomartin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/combinators.rb
+- lib/parser.rb
+- lib/result.rb
+- spec/combinators_spec.rb
+- spec/parser_spec.rb
+- spec/result_spec.rb
+- spec/spec_helper.rb
+homepage: 
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/rodr0m4/parby
+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.5.2.3
+signing_key: 
+specification_version: 4
+summary: Happy little parser combinators
+test_files: []