atomy 0.1.1 → 0.6.3

data/lib/atomy/node/pretty.rb

@@ -0,0 +1,108 @@
+require "atomy/grammar"
+
+module Atomy::Grammar::AST
+  class Sequence
+    def to_s
+      @nodes.join(", ")
+    end
+  end
+
+  class Number
+    def to_s
+      @value.to_s
+    end
+  end
+
+  class Literal
+    def to_s
+      @value.to_s
+    end
+  end
+
+  class Quote
+    def to_s
+      "'#@node"
+    end
+  end
+
+  class QuasiQuote
+    def to_s
+      "`#@node"
+    end
+  end
+
+  class Unquote
+    def to_s
+      "~#@node"
+    end
+  end
+
+  class Constant
+    def to_s
+      @text.to_s
+    end
+  end
+
+  class Word
+    def to_s
+      word = @text.to_s
+      word[0] + word[1..-1].tr("_", "-")
+    end
+  end
+
+  class Prefix
+    def to_s
+      "#@operator#@node"
+    end
+  end
+
+  class Postfix
+    def to_s
+      "#@node#@operator"
+    end
+  end
+
+  class Infix
+    def to_s
+      if @left
+        "(#@left #@operator #@right)"
+      else
+        "(#@operator #@right)"
+      end
+    end
+  end
+
+  class Block
+    def to_s
+      if @nodes.empty?
+        "{}"
+      else
+        "{ #{@nodes.join(", ")} }"
+      end
+    end
+  end
+
+  class List
+    def to_s
+      "[#{@nodes.join(", ")}]"
+    end
+  end
+
+  class Compose
+    def to_s
+      "(#@left #@right)"
+    end
+  end
+
+  class Apply
+    def to_s
+      "#@node(#{@arguments.join(", ")})"
+    end
+  end
+
+  class StringLiteral
+    def to_s
+      @value.inspect
+    end
+  end
+end

data/lib/atomy/parser.rb

@@ -0,0 +1,21 @@
+require "atomy/grammar"
+
+module Atomy
+  module Parser
+    extend self
+
+    def parse_file(file)
+      parse_string(File.read(file))
+    end
+
+    def parse_string(source)
+      grammar = Atomy::Grammar.new(source)
+
+      grammar.raise_error unless grammar.parse
+
+      grammar.result
+    rescue KPeg::CompiledParser::ParseError => e
+      raise SyntaxError, e.to_s
+    end
+  end
+end

data/lib/atomy/pattern.rb

@@ -0,0 +1,26 @@
+require "atomy/node/constructable"
+require "rubinius/ast"
+
+module Atomy
+  class Pattern
+    attr_accessor :from_node
+
+    def ===(v)
+      matches?(v)
+    end
+
+    def matches?(gen)
+      raise NotImplementedError
+    end
+
+    def target
+      raise NotImplementedError
+    end
+
+    def inline_matches?(gen)
+      gen.push_literal(self)
+      gen.swap
+      gen.send(:matches?, 1)
+    end
+  end
+end

data/lib/atomy/pattern/and.rb

@@ -0,0 +1,59 @@
+require "atomy/pattern"
+
+class Atomy::Pattern
+  class And < self
+    attr_reader :a, :b
+
+    def initialize(a, b)
+      @a = a
+      @b = b
+    end
+
+    def matches?(val)
+      @a.matches?(val) && @b.matches?(val)
+    end
+
+    def inline_matches?(gen)
+      mismatch = gen.new_label
+      done = gen.new_label
+
+      # [value, value]
+      gen.dup
+
+      # [bool, value]
+      @a.inline_matches?(gen)
+
+      # [value]
+      gen.gif(mismatch)
+
+      # [bool]
+      @b.inline_matches?(gen)
+
+      # [bool]
+      gen.goto(done)
+
+      # [value]
+      mismatch.set!
+
+      # []
+      gen.pop
+
+      # [bool]
+      gen.push_false
+
+      # [bool]
+      done.set!
+    end
+
+    def assign(gen)
+      @a.assign(gen)
+      @b.assign(gen)
+    end
+
+    def target
+      a = @a.target
+      b = @b.target
+      a < b ? a : b
+    end
+  end
+end

data/lib/atomy/pattern/attribute.rb

@@ -0,0 +1,16 @@
+require "atomy/pattern"
+
+class Atomy::Pattern
+  class Attribute < self
+    attr_reader :receiver, :arguments
+
+    def initialize(receiver, arguments = [])
+      @receiver = receiver
+      @arguments = arguments
+    end
+
+    def matches?(_)
+      true
+    end
+  end
+end

data/lib/atomy/pattern/class_variable.rb

@@ -0,0 +1,15 @@
+require "atomy/pattern"
+
+class Atomy::Pattern
+  class ClassVariable < self
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def matches?(_)
+      true
+    end
+  end
+end

data/lib/atomy/pattern/equality.rb

@@ -0,0 +1,42 @@
+require "atomy/pattern"
+
+class Atomy::Pattern
+  class Equality < self
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def matches?(val)
+      @value == val
+    end
+
+    def inline_matches?(gen)
+      push_value(gen)
+      gen.swap
+      gen.send(:==, 1)
+    end
+
+    def target
+      @value.class
+    end
+
+    private
+
+    def push_value(gen)
+      case @value
+      when true
+        gen.push_true
+      when false
+        gen.push_false
+      when nil
+        gen.push_nil
+      when Integer
+        gen.push_int(@value)
+      else
+        gen.push_literal(@value)
+      end
+    end
+  end
+end

data/lib/atomy/pattern/instance_variable.rb

@@ -0,0 +1,15 @@
+require "atomy/pattern"
+
+class Atomy::Pattern
+  class InstanceVariable < self
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def matches?(_)
+      true
+    end
+  end
+end

data/lib/atomy/pattern/kind_of.rb

@@ -0,0 +1,20 @@
+require "atomy/pattern"
+require "atomy/pattern/wildcard"
+
+class Atomy::Pattern
+  class KindOf < self
+    attr_reader :klass
+
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def matches?(val)
+      val.kind_of?(@klass)
+    end
+
+    def target
+      @klass
+    end
+  end
+end

data/lib/atomy/pattern/or.rb

@@ -0,0 +1,48 @@
+require "atomy/pattern"
+
+class Atomy::Pattern
+  class Or < self
+    attr_reader :a, :b
+
+    def initialize(a, b)
+      @a = a
+      @b = b
+    end
+
+    def matches?(val)
+      @a.matches?(val) || @b.matches?(val)
+    end
+
+    def inline_matches?(gen)
+      match = gen.new_label
+      done = gen.new_label
+
+      # [value, value]
+      gen.dup
+
+      # [bool, value]
+      @a.inline_matches?(gen)
+
+      # [value]
+      gen.git(match)
+
+      # [bool]
+      @b.inline_matches?(gen)
+
+      # [bool]
+      gen.goto(done)
+
+      # [value]
+      match.set!
+
+      # []
+      gen.pop
+
+      # [bool]
+      gen.push_true
+
+      # [bool]
+      done.set!
+    end
+  end
+end

data/lib/atomy/pattern/quasi_quote.rb

@@ -0,0 +1,164 @@
+require "atomy/pattern"
+
+require "atomy/node/meta"
+require "atomy/pattern/equality"
+
+
+class Atomy::Pattern
+  class QuasiQuote < self
+    attr_reader :node
+
+    def self.patterns_through(mod, node)
+      constructor = Constructor.new(mod)
+      constructor.go(node)
+    end
+
+    def self.make(mod, node)
+      new(mod.evaluate(patterns_through(mod, node)))
+    end
+
+    def initialize(node)
+      @node = node
+    end
+
+    def matches?(val)
+      MatchWalker.new.go(@node, val)
+    end
+
+    private
+
+    class Walker
+      def initialize
+        @depth = 0
+      end
+
+      def go(x)
+        x.accept(self)
+      end
+
+      def visit_quasiquote(qq)
+        @depth += 1
+        visit(qq)
+      ensure
+        @depth -= 1
+      end
+
+      def visit_unquote(x)
+        @depth -= 1
+
+        if @depth == 0
+          unquote(x)
+        else
+          visit(x)
+        end
+      ensure
+        @depth += 1
+      end
+
+      def unquote(_)
+        raise NotImplementedError
+      end
+
+      def push_literal(x)
+        case x
+        when Array
+          x.each { |v| push_literal(v) }
+          @gen.make_array(x.size)
+        when String
+          @gen.push_literal(x)
+          @gen.string_dup
+        else
+          @gen.push_literal(x)
+        end
+      end
+
+      def unsplat(pats)
+        if pats.last.is_a?(Atomy::Grammar::AST::Unquote) && \
+            pats.last.node.is_a?(Atomy::Pattern::Splat)
+          [pats[0..-2], pats[-1]]
+        else
+          [pats, nil]
+        end
+      end
+    end
+
+    class Constructor < Walker
+      def initialize(mod)
+        super()
+
+        @module = mod
+      end
+
+      def go(x)
+        x.accept(self)
+      end
+
+      def visit(x)
+        x.through do |v|
+          go(v)
+        end
+      end
+
+      def unquote(x)
+        x.through do |p|
+          @module.pattern(p)
+        end
+      end
+    end
+
+    class MatchWalker
+      def go(a, b)
+        if a.is_a?(Atomy::Pattern)
+          a.matches?(b)
+        elsif b.is_a?(a.class)
+          a.each_attribute do |attr, val|
+            return false unless val == b.send(attr)
+          end
+
+          a.each_child do |attr, val|
+            theirval = b.send(attr)
+
+            if val.is_a?(Array) # TODO test that theirval is an array too
+              return false unless go_array(val, theirval)
+            else
+              return false unless go(val, b.send(attr))
+            end
+          end
+
+          true
+        else
+          false
+        end
+      end
+
+      def go_array(as, bs)
+        splat = nil
+        req_size = 0
+        as.each do |a|
+          if a.is_a?(Atomy::Pattern::Splat)
+            splat = a
+            break
+          end
+
+          req_size += 1
+        end
+
+        if splat
+          return false unless bs.size >= req_size
+        else
+          return false unless bs.size == req_size
+        end
+
+        req_size.times do |i|
+          return false unless go(as[i], bs[i])
+        end
+
+        if splat
+          return false unless splat.matches?(bs[req_size..-1])
+        end
+
+        true
+      end
+    end
+  end
+end