satre 0.1.0 → 1.0.0

data/lib/satre/parser/lexer.rb

@@ -0,0 +1,55 @@
+module Satre
+  class Lexer
+    class << self
+      def matches
+        lambda { |pattern, str| str.split("").all? { |c| pattern.include? c } }
+      end
+
+      def matches(pattern, str)
+        str.split("").all? { |c| pattern.include? c }
+      end
+      
+      def space?(str)
+        matches(" \t\n\r", str)
+      end
+
+      def punctuation?(str)
+        matches("()[]{}", str)
+      end
+
+      def symbolic?(str)
+        matches("~`!@#%$^&*-+<=>\\/|", str)
+      end
+
+      def numeric?(str)
+        matches("0123456789", str)
+      end
+
+      def alpanumeric?(str)
+        matches("abcdefghijklmnopqrstuvwxyz_'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", str)
+      end
+
+      def refute(*)
+        false
+      end
+
+      def lexwhile(prop, inp)
+        tokl = inp.split("").take_while { |c| self.send(prop, c) }.inject(:+)
+        tokl = "" if tokl.nil? 
+        return tokl, inp[tokl.length..-1]
+      end
+
+      def lex(inp)
+        inp, rest = self.lexwhile(:space?, inp)
+        return [] if rest == "" || rest.nil?
+        c = rest[0]
+        cs = rest[1..-1]
+        prop =  if self.alpanumeric?(c) then :alpanumeric?
+                elsif self.symbolic?(c) then :symbolic?
+                else :refute end
+        toktl, rest = self.lexwhile(prop, cs)
+        [c+toktl] + lex(rest)
+      end
+    end
+  end
+end

data/lib/satre/parser/parser.rb

@@ -0,0 +1,80 @@
+require 'satre/parser/lexer'
+require 'satre/formula'
+require 'satre/errors'
+
+module Satre
+  class Parser
+    class << self
+      def make_parser(parsing_function, input)
+        expr, rest = parsing_function.call(Lexer.lex(input))
+        fail(ParserError, "Unparsed input: #{rest}") unless rest == []
+        return expr
+      end
+
+      def is_const_name(string)
+        string.split('').all? { |c| Lexer.numeric?(c)  } || string.nil?
+      end
+
+      ###
+      # Generic parsing function
+      # sof: function -> takes the current input and combines it in some way with the items arravied at so far
+      # opupdate: function -> modifies the function appropriately when an new item is parsed.
+      ###
+      def parse_ginfix(opsym, opupdate, sof, subparser, inp)
+        e1, inp1 = subparser.call(inp)
+        if inp1 != [] && inp1[0] == opsym
+          parse_ginfix(opsym, opupdate, opupdate.curry.call(sof, e1), subparser, inp1[1..-1])
+        else
+          return sof.call(e1), inp1
+        end
+      end
+
+      # parse a list of items and combine them in a left associated manner
+      # returns a lambda
+      def parse_left_infix(opsym, opcon)
+        opupdate = ->(f, e1 ,e2) {opcon.call(f.call(e1), e2) }
+        sof = ->(x) { x }
+        method(:parse_ginfix).curry.call(opsym, opupdate, sof)
+      end
+
+      # parse a list of items and combine them in a right associated manner
+      # returns a lambda
+      def parse_right_infix(opsym, opcon)
+        opupdate = ->(f,e1,e2) { f.call(opcon.call(e1,e2)) }
+        sof = ->(x) { x }
+        method(:parse_ginfix).curry.call(opsym, opupdate, sof)
+      end
+
+      # parse a list of items and collect them in a list
+      def parse_list(opsym)
+        opupdate = ->(f,e1,e2) {  f.call(e1) << e2 }
+        sof = ->(x) { [x] }
+        method(:parse_ginfix).curry.call(opsym, opupdate, sof)
+      end
+
+      # Applies a function to the first element of a pair.
+      # The idea being to modify the returned abstract syntax tree while leaving
+      # the `unparsed input` alone
+      def papply(f, ast, rest)
+        return f.call(ast), rest
+      end
+
+      # Checks if the head of a list (typically the list of unparsed input)
+      # is some particular item, but also first checks that the list is nonempty
+      # before looking at its head
+      def nextin(inp, tok)
+        inp != [] && inp.first == tok
+      end
+
+      # Deals with the common situation of syntastic items enclosed in brackets
+      # It simply calls the subparser and  then checks and eliminates
+      # the closing bracket. In principle, the therminating character can be anything,
+      # so this function could equally be used for other purposes.
+      def parse_bracketed(subparser, closing_character, inp)
+        ast, rest = subparser.call(inp)
+        return ast, rest[1..-1] if nextin(rest, closing_character)
+        fail(ExpressionError, "Expected closing character '#{closing_character}'")
+      end
+    end
+  end
+end

data/lib/satre/parser/term_parser.rb

@@ -0,0 +1,85 @@
+require 'satre/parser/parser'
+
+module Satre
+  class TermParser < Parser
+    class << self
+
+      # vs: set of bounds variables in the current scope
+      # inp: current input 
+      def parse_atomic_term(vs, inp)
+        fail(ArgumentError, 'Term expected') if inp == []
+        head = inp.first
+        rest = inp[1..-1]
+        if head == '(' then parse_bracketed(method(:parse_term).curry.call(vs), ")", rest)
+        elsif head == '-' then papply( ->(t) { Function.new("-", [t])}, method(:parse_atomic_term).curry.call(vs), rest )
+        elsif Lexer.alpanumeric?(head) && rest[0] == '('
+          if rest[1] == ')'
+            papply( -> { Function.new(head, []) }, rest[2..-1])
+          else
+            ast, rest = parse_bracketed(parse_list(',').call(method(:parse_term).curry.call(vs)) , ')', rest[1..-1])
+            papply(->(args) { Function.new(head, args) }, ast, rest)
+          end
+        else
+          a = if is_const_name(head) && !vs.include?(head) then Function.new(head,[]) else Variable.new(head) end
+          return a, rest
+        end
+      end
+
+      # build up parsing of general terms via parsing of the various infix operations
+      def parse_term(vs, inp)
+        colon = parse_right_infix("::", ->(e1,e2) { Function.new('::', [e1, e2]) })
+        plus = parse_right_infix("+", ->(e1,e2) { Function.new('+', [e1, e2]) })
+        minus = parse_left_infix("-", ->(e1,e2) { Function.new('-', [e1, e2]) })
+        mul = parse_right_infix("*", ->(e1,e2) { Function.new('*', [e1, e2]) })
+        div = parse_left_infix("/", ->(e1,e2) { Function.new('/', [e1, e2]) })
+        power = parse_left_infix("^", ->(e1,e2) { Function.new('^', [e1, e2]) })
+        atom = method(:parse_atomic_term).curry.call(vs)
+        colon.call(plus.call(minus.call(mul.call(div.call(power.call(atom))))), inp)
+      end
+
+      def is_const_name(string)
+        string.split('').all? { |c| Lexer.numeric?(c)  } || string.nil?
+      end
+      
+
+      def parse_atom(vs, inp)
+        FormulaParser.parse_infix_atom(vs, inp)
+        rescue ParserError
+          head = inp.first
+          rest = inp[1..-1]
+          if rest[0] == '('
+            rest = rest[1..-1]
+            if rest[0] == ')' 
+              return Atom.new(Relation.new(head, [])), rest[1..-1]
+            else
+              ast, rest = parse_bracketed(parse_list(',').call(method(:parse_term).curry.call(vs)),')', rest)
+              papply( ->(args) { Atom.new(Relation.new(head,args))}, ast, rest)
+            end
+          else
+            return Atom.new(Relation.new(head, [])), rest if head != '('
+            fail(ParserError, 'Parse Atom')
+          end
+      end
+
+      def parse_formula(ifn, afn, vs, inp)
+        parse_Entails = parse_right_infix("|=", ->(p,q) { Entails.new(p,q)})
+        parse_Iff = parse_right_infix("<=>", ->(p,q) { Iff.new(p,q)})
+        parse_Imp = parse_right_infix("==>", ->(p,q) { Imp.new(p,q)})
+        parse_Or = parse_right_infix("\\/", ->(p,q) { Or.new(p,q)})
+        parse_And = parse_right_infix("/\\", ->(p,q) { And.new(p,q)})
+        parse_Atom = method(:parse_atomic_formula).curry.call(ifn, afn, vs)
+        parse_Entails.call(parse_Imp.call(parse_Or.call(parse_And.call(parse_Iff.call(parse_Atom)))),inp)
+      end
+
+      def parse(inp)
+        make_parser(method(:parse_term).curry.call([]), inp)
+      end
+    end
+  end
+end
+
+class String
+  def to_term
+    Satre::TermParser.parse(self)
+  end
+end

data/lib/satre/version.rb

@@ -1,3 +1,3 @@
 module Satre
-  VERSION = '0.1.0'
+  VERSION = '1.0.0'
 end

data/satre.gemspec

@@ -37,4 +37,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'rubocop'
   spec.add_development_dependency 'guard-rubocop'
+  spec.add_development_dependency 'codeclimate-test-reporter'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: satre
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Roman C. Podolski
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-01-10 00:00:00.000000000 Z
+date: 2016-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: terminal-table
@@ -164,6 +164,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: "\n  I think therefore I am.\n  \n  Satre is a library for proportional
   and first order logic.\n  It was inspired by the book 'Handbook of practical logic
   and automated reasoning' by Harrison, J (2009).\n  \n  This project originated at
@@ -188,27 +202,36 @@ files:
 - bin/exercise
 - bin/setup
 - lib/satre.rb
-- lib/satre/expression.rb
-- lib/satre/expression/add.rb
-- lib/satre/expression/const.rb
-- lib/satre/expression/expression.rb
-- lib/satre/expression/expression_parser.rb
-- lib/satre/expression/mul.rb
-- lib/satre/expression/var.rb
+- lib/satre/errors.rb
+- lib/satre/errors/argument_error.rb
+- lib/satre/errors/expression_error.rb
+- lib/satre/errors/parser_error.rb
 - lib/satre/formula.rb
-- lib/satre/formula/and.rb
-- lib/satre/formula/atom.rb
-- lib/satre/formula/entails.rb
-- lib/satre/formula/false.rb
+- lib/satre/formula/first_order_logic.rb
+- lib/satre/formula/first_order_logic/exists.rb
+- lib/satre/formula/first_order_logic/fol_formula.rb
+- lib/satre/formula/first_order_logic/forall.rb
+- lib/satre/formula/first_order_logic/relation.rb
 - lib/satre/formula/formula.rb
-- lib/satre/formula/iff.rb
-- lib/satre/formula/imp.rb
-- lib/satre/formula/not.rb
-- lib/satre/formula/or.rb
-- lib/satre/formula/true.rb
-- lib/satre/formula_parser.rb
-- lib/satre/lexer.rb
+- lib/satre/formula/propositional_logic.rb
+- lib/satre/formula/propositional_logic/and.rb
+- lib/satre/formula/propositional_logic/atom.rb
+- lib/satre/formula/propositional_logic/entails.rb
+- lib/satre/formula/propositional_logic/false.rb
+- lib/satre/formula/propositional_logic/iff.rb
+- lib/satre/formula/propositional_logic/imp.rb
+- lib/satre/formula/propositional_logic/not.rb
+- lib/satre/formula/propositional_logic/or.rb
+- lib/satre/formula/propositional_logic/true.rb
+- lib/satre/formula/term.rb
+- lib/satre/formula/term/function.rb
+- lib/satre/formula/term/term.rb
+- lib/satre/formula/term/variable.rb
 - lib/satre/parser.rb
+- lib/satre/parser/formula_parser.rb
+- lib/satre/parser/lexer.rb
+- lib/satre/parser/parser.rb
+- lib/satre/parser/term_parser.rb
 - lib/satre/version.rb
 - satre.gemspec
 homepage: http://in.tum.de

data/lib/satre/expression.rb

@@ -1,6 +0,0 @@
-require 'satre/expression/expression'
-require 'satre/expression/add'
-require 'satre/expression/const'
-require 'satre/expression/expression_parser'
-require 'satre/expression/mul'
-require 'satre/expression/var'

data/lib/satre/expression/add.rb

@@ -1,26 +0,0 @@
-require 'satre/expression'
-
-# A parster for propositional statements
-# and simple mathematical expressions
-module Satre
-  class Add < Expression
-    attr_reader :p
-    attr_reader :q
-
-    def initialize(p,q)
-      fail(ArgumentError, 'p must be a expression') unless p.is_a?(Expression)
-      fail(ArgumentError, 'q must be a expression') unless p.is_a?(Expression)
-      @p = p.dup.freeze
-      @q = q.dup.freeze
-      super "Add (#{@p},#{@q})"
-    end
-
-    def eval
-      p.eval + q.eval
-    end
-
-    def self.parse(e)
-      fail 'not yet implemented'
-    end
-  end
-end

data/lib/satre/expression/const.rb

@@ -1,23 +0,0 @@
-require 'satre/expression'
-
-# A parster for propositional statements
-# and simple mathematical expressions
-module Satre
-  class Const < Expression
-    attr_reader :i
-
-    def initialize(i)
-      ArgumentError 'argument must be an integer' unless i.is_a? Integer
-      @i = i
-      super "Const #{i}"
-    end
-
-    def eval
-      i
-    end
-
-    def self.parse(e)
-      fail 'not yet implemented'
-    end
-  end
-end

data/lib/satre/expression/expression.rb

@@ -1,22 +0,0 @@
-module Satre
-  class Expression
-    attr_reader :base
-
-    def initialize(base)
-      fail(ArgumentError, 'argument must be a string') unless base.is_a?(String)
-      @base = base.dup.freeze
-    end
-
-    def to_s
-      base
-    end
-
-    def eval # abstract method
-      fail 'abstract'
-    end
-
-    def simplify
-      fail 'not yet implemented'
-    end
-  end
-end

data/lib/satre/expression/expression_parser.rb

@@ -1,56 +0,0 @@
-require 'satre/parser'
-
-module Satre
-  class ExpressionParser < Parser
-    class << self
-      def parse_expression
-        lambda do |inp| 
-          e1, i1 = parse_product(inp) 
-          if i1[0] == '+' 
-            e2, i2 = parse_expression.call(i1.drop(1))
-            return Add.new(e1, e2), i2
-          end
-          return e1, i1
-        end
-      end
-
-      def parse_product(inp)
-        e1, i1 = parse_atom(inp)
-        if i1[0] == '*' 
-          e2,i2 = parse_expression.call(i1.drop(1))
-          return Mul.new(e1, e2), i2
-        end
-        return e1, i1
-      end
-
-      def parse_atom(inp)
-        fail(ArgumentError, 'Expected an expression at end of input') if inp == []
-        if inp[0] == '('
-          e2, i2 = parse_expression.call(inp.drop(1))
-          if i2[0] == ')'
-            return e2, i2.drop(1)
-          else
-            fail(ExpressionError, 'Expected closing bracket')
-          end
-        else
-          if Lexer.numeric?.call(inp[0])
-            return Const.new(inp[0].to_i), inp.drop(1)
-          else
-            return Var.new(inp[0]), inp.drop(1)
-          end
-        end
-      end
-
-      def parse(inp)
-        make_parser.curry.call(parse_expression).call(inp)
-      end
-    end
-
-  end
-end
-
-class String
-  def to_expression
-    Satre::ExpressionParser.parse(self)
-  end
-end