erle 0.1.0

data/lib/erle/elements/list.rb

@@ -0,0 +1,9 @@
+module ERLE
+
+  class List < Enum
+    enclosure /\[/, /\]/
+    @delimeter = ','
+
+  end
+
+end

data/lib/erle/elements/map.rb

@@ -0,0 +1,9 @@
+module ERLE
+
+  class Map < Enum
+    enclosure /\#\{/, /\}/
+    @delimeter = ','
+
+  end
+
+end

data/lib/erle/elements/numbers.rb

@@ -0,0 +1,26 @@
+module ERLE
+
+  class Number < Term
+
+  end
+
+  class Float < Number
+    pattern %r{[-0-9]\.[0-9]+}
+
+    def to_ruby
+      @output ||= @input.to_f
+    end
+
+  end
+
+  class Integer < Number
+
+    pattern %r{(-?0|-?[1-9]\d*)}
+
+    def to_ruby
+      @output ||= @input.to_i
+    end
+
+  end
+
+end

data/lib/erle/elements/pid.rb

@@ -0,0 +1,22 @@
+module ERLE
+
+  # http://erlang.org/doc/reference_manual/data_types.html#id68255
+  class Pid < Term
+
+    class Data < ::String
+
+      def to_erl
+        "<#{self}>"
+      end
+    end
+
+    enclosure /</, />/
+    pattern %r{[-0-9](\.[0-9])+}
+    # @delimeter = '.'
+
+    def to_ruby
+      @output ||= Data.new(@input)
+    end
+  end
+
+end

data/lib/erle/elements/ref.rb

@@ -0,0 +1,37 @@
+module ERLE
+
+  class Ref < Term
+    enclosure /\#Ref</, />/
+
+    @delimeter = "."
+
+    @pattern = %r{(?:(\d+)\.?)+}
+
+    def initialize(input)
+      @input = input
+    end
+
+    # TODO: Leverage Enum, and refactor (Enum) to handle conflicting delimiters
+    # e.g. a "." delimeter is preempted by the "float" pattern.
+    def to_ruby
+      @output ||= @input.split(".")
+    end
+
+    def self.parse(parser)
+
+      result = parser.scan(@pattern)
+
+      if close && !parser.scan(close)
+        raise parser.raise_unexpected_token("Expected term closure \" #{close.source} \"")
+      end
+
+      # Make sure we kill any trailing close
+      # TODO: Consider raising if no match?
+      # TODO: Consider doing only if we started with an opening...
+      # parser.scan(ERLE::Registry.closings_regex)
+      new(result)
+    end
+
+  end
+
+end

data/lib/erle/elements/string.rb

@@ -0,0 +1,33 @@
+module ERLE
+
+  class String < Term
+    enclosure /\"/
+    # pattern %r{((?:[^\x0-\x1f'\\] |
+    #              # escaped special characters:
+    #             \\["/bfnrt] |
+    #             \\u[0-9a-fA-F]{4} |
+    #              # match all but escaped special characters:
+    #             \\[\x20-\x21\x23-\x2e\x30-\x5b\x5d-\x61\x63-\x65\x67-\x6d\x6f-\x71\x73\x75-\xff])*)
+    #         }nx
+
+    PATTERN = %r{[^\"]*}nx
+
+    def to_ruby
+      # self.str.gsub(/"/,"")
+      @output ||= @input
+    end
+
+    def self.parse(parser)
+      opener = parser.matched == "\""
+
+      parser.scan(PATTERN)
+      result = parser.matched
+
+      parser.scan(close) if opener
+
+      new(result)
+    end
+
+  end
+
+end

data/lib/erle/elements/term.rb

@@ -0,0 +1,71 @@
+module ERLE
+
+  class Term
+
+    class << self
+      attr_accessor :open, :close, :patterns
+    end
+
+    attr_accessor :input
+    attr_accessor :output
+
+
+    def self.patterns
+      @patterns ||= Set.new
+    end
+
+    def self.pattern(p)
+      patterns.add(p)
+      ERLE::Registry.pattern(self, p)
+    end
+
+    def self.enclosure(one, two=one)
+      @open = one.freeze
+      @close = two.freeze
+      ERLE::Registry.enclosure(self, one, two)
+    end
+
+    def initialize(input)
+      @input = input
+    end
+
+    def to_ruby
+      @input
+    end
+
+    def self.to_ruby(value)
+      case value
+      when Term
+        value.to_ruby
+      else
+        value
+      end
+    end
+
+    def self.until_any_closing
+      @until_any_closing ||= Regexp.new("[^#{ERLE::Registry.closings_regex.source}]*")
+    end
+
+    def self.parse(parser)
+
+      patterns.find do |pattern|
+        parser.scan(pattern)
+      end
+
+      result = parser.matched
+
+      if close && !parser.scan(close)
+        raise parser.raise_unexpected_token("Expected term closure \" #{close.source} \"")
+      end
+
+      # # Make sure we kill any trailing close
+      # # TODO: Consider raising if no match?
+      # # TODO: Consider doing only if we started with an opening...
+      # parser.scan(ERLE::Registry.closings_regex)
+      # # binding.pry
+      new(result)
+    end
+
+  end
+
+end

data/lib/erle/elements/tuple.rb

@@ -0,0 +1,37 @@
+module ERLE
+
+  class Tuple < Enum
+    enclosure /\{/, /\}/
+    @delimeter = ','
+
+    attr_accessor :key
+
+    def initialize(elements)
+      super
+      @key = Term.to_ruby(@terms.shift)
+    end
+
+    def to_ruby
+      @output ||= { @key => one_or_all(terms_to_ruby) }
+    end
+
+  end
+
+end
+
+module ERLE
+
+  class Luple < Enum
+    # register "[{", "}]"
+
+    def to_ruby
+      # @output = Enum.split("},{")
+      # arr = @output.map {|el|
+      #   el.is_a?(Term) ? el.to_ruby : el
+      # }
+      # key = arr.delete_at(0)
+      # hash = {key => ( arr.length>1 ? arr: arr[0])}
+    end
+  end
+
+end

data/lib/erle/errors.rb

@@ -0,0 +1,12 @@
+module ERLE
+
+  class Error < StandardError
+  end
+
+  class ParserError < ERLE::Error
+  end
+
+  class NestingError < ParserError
+  end
+
+end

data/lib/erle/parser.rb

@@ -0,0 +1,122 @@
+
+require 'erle/registry'
+
+module ERLE
+
+  class Parser < StringScanner
+
+    UNPARSED              = Object.new.freeze
+    IGNORE                = %r(
+                              (?:
+                               //[^\n\r]*[\n\r]| # line comments
+                               /\*               # c-style comments
+                               (?:
+                                [^*/]|        # normal chars
+                                /[^*]|        # slashes that do not start a nested comment
+                                \*[^/]|       # asterisks that do not end this comment
+                                /(?=\*/)      # single slash before this comment's end
+                               )*
+                                 \*/               # the End of this comment
+                                 |[ \t\r\n]+       # whitespaces: space, horicontal tab, lf, cr
+                              )+
+                            )mx
+
+    INTEGER               = /(-?0|-?[1-9]\d*)/
+    FLOAT                 = /(-?
+                            (?:0|[1-9]\d*)
+                            (?:
+                              \.\d+(?i:e[+-]?\d+) |
+                              \.\d+ |
+                              (?i:e[+-]?\d+)
+                            )
+                            )/x
+    TRUE                  = /true/
+    FALSE                 = /false/
+
+    def initialize(source, opts = {})
+      opts ||= {}
+      # source = convert_encoding source
+      super source
+    end
+
+    alias source string
+
+    def parse
+      reset
+      obj = nil
+
+      until_done do
+        if eos?
+          raise_parsing_error
+        else
+          obj = parse_value
+          UNPARSED.equal?(obj) and raise_parsing_error
+        end
+      end
+
+      eos? or raise_parsing_error
+      obj
+    end
+
+    def skip_ignore
+      skip(IGNORE)
+    end
+
+    def until_done
+      result = nil
+      while !eos?
+        skip_ignore
+        result = yield if block_given?
+        skip_ignore
+      end
+      result
+    end
+
+    def peekaboo(peek = 30, back = 30)
+      string[pos-back, peek+back]
+    end
+
+    def raise_parsing_error(message = "source is not valid Erlang!")
+      # warn "Parsing =>\n#{string}"
+      raise ParserError, "Parsing =>\n#{string}\n#{message}"
+    end
+
+    def whereami?(peek = 30, back = 30)
+      back = [back, string.length - pos].sort[0]
+      "#{peekaboo(peek, back)}'\n#{"─" * (back)}┘"
+    end
+
+    def raise_unexpected_token(followup=nil)
+      message = "Unexpected token at:\n#{whereami?}"
+      message += "\n#{followup}" if followup
+      raise ParserError, message
+    end
+
+    def parse_value
+      # TODO: handle symbols
+      skip_ignore
+
+      case
+      when scan(TRUE)
+        true
+      when scan(FALSE)
+        false
+      when !eos? && scan(ERLE::Registry.openings_regex) # TODO: Take out !eos?
+        regex, term_class = ERLE::Registry.open_find(matched)
+        term_str = term_class.parse(self)
+      else
+        term_class, regex = ERLE::Registry.pattern_find do |p|
+          match?(p)
+        end
+
+        if term_class
+          term_class.parse(self)
+        else
+          UNPARSED
+        end
+      end
+    end
+
+  end
+
+end

data/lib/erle/registry.rb

@@ -0,0 +1,71 @@
+module ERLE
+
+  module Registry
+    class << self
+      attr_accessor :_enclosures
+      attr_accessor :_patterns
+    end
+
+    @_enclosures = {}
+    @_patterns = {}
+
+    def self.enclosure(klass, one, two)
+      @_enclosures[one] = klass
+    end
+
+    def self.pattern(klass, pat)
+      (@_patterns[klass] ||= Set.new).add(pat)
+    end
+
+    def self.pattern_find
+      return unless block_given?
+      @_patterns.each do |klass, patterns|
+        pattern = patterns.find do |pattern|
+          yield(pattern)
+        end
+        return [klass, pattern] if pattern
+      end
+      nil
+    end
+
+    def self.open_find(str)
+      sorted_encolsures.find do |k, v|
+        str =~ k
+      end
+    end
+
+    def self.sorted_encolsures
+      @sorted_encolsures ||= @_enclosures.sort_by { |pattern, klass| pattern.source.length }.reverse.to_h
+    end
+
+    def self.openings
+      @openings ||= sorted_encolsures.keys
+    end
+
+    def self.openings_source
+      @openings_source ||= openings.map(&:source)
+    end
+
+    def self.openings_regex
+      @openings_regex ||= Regexp.new("(#{openings_source.join('|')})")
+    end
+
+    # def self.close_find(str)
+    #   @_enclosures.values.find do |klass|
+    #     str =~ klass.close
+    #   end
+    # end
+
+    # def self.closings
+    #   @closings ||= @_enclosures.values.collect(&:close).sort { |a, b| b.source.length <=> a.source.length }
+    # end
+
+    # def self.closings_source
+    #   @closings_source ||= closings.map(&:source)
+    # end
+
+    # def self.closings_regex
+    #   @closings_regex ||= Regexp.new("(#{closings_source.join('|')})")
+    # end
+  end
+end