atomy 0.1.1

data/lib/namespace.rb

@@ -0,0 +1,236 @@
+module Atomy
+  NAMESPACES = {}
+  NAMESPACE_DELIM = "_ns_"
+
+  def self.namespaced(ns, name)
+    return name.to_s if !ns or ns == "_"
+    ns.to_s + NAMESPACE_DELIM + name.to_s
+  end
+
+  def self.from_namespaced(resolved)
+    split = resolved.to_s.split(NAMESPACE_DELIM)
+    meth_name = split.pop
+    ns_name = !split.empty? && split.join(NAMESPACE_DELIM)
+    [ns_name, meth_name]
+  end
+
+  class Namespace
+    attr_reader :name, :using, :symbols
+
+    def initialize(name, using = [])
+      using = [:atomy] + using unless name == :atomy
+
+      @name = name
+      @using = using
+      @symbols = []
+    end
+
+    def register(sym)
+      @symbols << sym unless contains?(sym)
+    end
+
+    def contains?(sym)
+      @symbols.include?(sym)
+    end
+
+    def use(sym)
+      raise "namespace `#{sym}` tried to use itself" if sym == @name
+      raise "unknown namespace `#{sym}'" unless ns = Namespace.get(sym)
+      raise "circular namespaces: `#{@name}' <=> `#{sym}'" if ns.uses?(@name)
+      @using << sym unless @using.include?(sym)
+    end
+
+    def uses?(ns)
+      return true if @using.include?(ns)
+
+      @using.each do |u|
+        return true if Namespace.get(u).uses?(ns)
+      end
+
+      false
+    end
+
+    def resolve(sym)
+      return @name if contains?(sym)
+
+      @using.each do |ns|
+        unless used = Namespace.get(ns)
+          raise "unknown namespace: #{ns.inspect}"
+        end
+
+        return ns if used.contains?(sym)
+      end
+
+      nil
+    end
+
+    def top_down(&blk)
+      yield @name
+      @using.each do |u|
+        Atomy::Namespace.get(u).top_down(&blk)
+      end
+      nil
+    end
+
+    def self.define_target
+      Thread.current.atomy_get_local(:atomy_define_in) ||
+        get && get.name.to_s
+    end
+
+    def self.ensure(name, using = [])
+      Thread.current.atomy_set_local(
+        :atomy_namespace,
+        create(name, using)
+      )
+    end
+
+    def self.create(name, using = [])
+      NAMESPACES[name.to_sym] ||=
+        new(name, using)
+    end
+
+    def self.get(name = nil)
+      return NAMESPACES[name.to_sym] if name
+      Thread.current.atomy_get_local(:atomy_namespace)
+    end
+
+    def self.set(x)
+      Thread.current.atomy_set_local(:atomy_namespace, x)
+    end
+
+    def self.register(sym, name = nil)
+      ns = get(name)
+      return unless ns
+      ns.register(sym)
+    end
+
+    def self.name
+      ns = get
+      return unless ns
+      ns.name
+    end
+
+    def self.try_methods(name)
+      ns_name, meth_name = Atomy.from_namespaced(name)
+
+      if ns_name != "_" and \
+          ns = Atomy::Namespace.get(ns_name && ns_name.to_sym)
+        ns.top_down do |name|
+          yield Atomy.namespaced(name, meth_name).to_sym
+        end
+      end
+
+      meth_name.to_sym
+    end
+  end
+end
+
+class Thread
+  def atomy_get_local(n)
+    @locals[n]
+  end
+
+  def atomy_set_local(n, v)
+    @locals[n] = v
+  end
+end
+
+# NOTE: this is currently not used
+# TODO: allow_private stuff
+=begin
+def Rubinius.bind_call(recv, nmeth, *args, &blk)
+  ns_name, meth_name = Atomy.from_namespaced(nmeth)
+
+  if ns_name == "_"
+    ns = nil
+  else 
+    ns = Atomy::Namespace.get(!ns_name ? nil : ns_name.to_sym)
+  end
+
+  meth = meth_name.to_sym
+
+  res = Rubinius::CallUnit.send_as(meth)
+
+  if ns
+    nss = [ns]
+    scan = proc do |u|
+      unless un = Atomy::Namespace.get(u) and \
+              !nss.include?(un)
+        next
+      end
+
+      nss << un
+      un.using.each(&scan)
+    end
+
+    ns.using.each(&scan)
+
+    nss.reverse_each do |n|
+      next unless n.contains?(meth)
+      m = Atomy.namespaced(n.name, meth).to_sym
+      res = Rubinius::CallUnit.test(
+        Rubinius::CallUnit.test_respond_to(m),
+        Rubinius::CallUnit.send_as(m),
+        res
+      )
+    end
+  end
+
+  res
+end
+=end
+
+class Object
+  alias :respond_to_atomy_old? :respond_to?
+
+  def respond_to?(nmeth, include_private = false)
+    return true if respond_to_atomy_old?(nmeth, include_private)
+
+    Atomy::Namespace.try_methods(nmeth) do |m|
+      return true if respond_to_atomy_old?(m, include_private)
+    end
+
+    false
+  end
+
+  def send(nmeth, *as, &blk)
+    if respond_to_atomy_old?(nmeth, true)
+      return __send__(nmeth, *as, &blk)
+    end
+
+    name = Atomy::Namespace.try_methods(nmeth) do |m|
+      if respond_to_atomy_old?(m, true)
+        return __send__(m, *as, &blk)
+      end
+    end
+
+    __send__(name, *as, &blk)
+  end
+
+  alias_method :atomy_send, :send
+
+  alias :method_atomy_old :method
+
+  def method(nmeth)
+    sym = Rubinius::Type.coerce_to_symbol nmeth
+    cm = Rubinius.find_method(self, sym)
+
+    return Method.new(self, cm[1], cm[0], sym) if cm
+
+    name = Atomy::Namespace.try_methods(nmeth) do |m|
+      cm = Rubinius.find_method(self, m)
+      return Method.new(self, cm[1], cm[0], m) if cm
+    end
+
+    method_atomy_old(name)
+  end
+end
+
+class Module
+  # TODO: alias_method, instance_method, module_function, private,
+  # private_class_method, protected, public, public_class_method
+  #
+  # TODO?: define_method, method_defined?, private_method_defined?,
+  # protected_method_defined?, public_method_defined?, remove_method,
+  # undef_method
+end

data/lib/parser.rb

@@ -0,0 +1,28 @@
+base = File.expand_path "../", __FILE__
+
+require base + "/atomy.kpeg.rb"
+
+module Atomy
+  class Parser
+    def self.parse_string(source)
+      p = new(source)
+      p.raise_error unless p.parse
+      AST::Tree.new(p.result)
+    end
+
+    def self.parse_file(name)
+      p = new(File.open(name, "rb").read)
+      p.raise_error unless p.parse
+      AST::Tree.new(p.result)
+    end
+  end
+
+  path = File.expand_path("../ast", __FILE__)
+
+  require path + "/node"
+
+  Dir["#{path}/**/*.rb"].sort.each do |f|
+    require f
+  end
+end
+

data/lib/patterns.rb

@@ -0,0 +1,276 @@
+class PatternMismatch < RuntimeError
+  def initialize(p)
+    @pattern = p
+  end
+end
+
+module Atomy::Patterns
+  class Pattern
+    attr_accessor :variable
+
+    # push the target class for this pattern in a defition
+    def target(g)
+      raise Rubinius::CompileError, "no #target for #{self}"
+    end
+
+    # test if the pattern mtaches the value at the top of the stack
+    # effect on the stack: top value removed, boolean pushed
+    def matches?(g)
+      raise Rubinius::CompileError, "no #matches? for #{self}"
+    end
+
+    # match the pattern on the value at the top of the stack
+    # effect on the stack: top value removed
+    def deconstruct(g, locals = {})
+      g.pop
+    end
+
+    # helper for pushing the current class const onto the stack
+    def get(g)
+      g.push_cpath_top
+      self.class.name.split("::").each do |n|
+        g.find_const n.to_sym
+      end
+    end
+
+    # create the pattern on the stack
+    def construct(g)
+      raise Rubinius::CompileError, "no #construct for #{self}"
+    end
+
+    def assign(g, expr, set = false)
+      locals = {}
+      local_names.each do |n|
+        locals[n] = Atomy.assign_local(g, n, set)
+      end
+
+      expr.compile(g)
+      g.dup
+      match(g, set, locals)
+    end
+
+    # try pattern-matching, erroring on failure
+    # effect on the stack: top value removed
+    def match(g, set = false, locals = {})
+      error = g.new_label
+      done = g.new_label
+
+      local_names.each do |n|
+        locals[n] ||= Atomy.assign_local(g, n, set)
+      end
+
+      g.dup
+      matches?(g)
+      g.gif error
+      deconstruct(g, locals)
+      g.goto done
+
+      error.set!
+      g.pop
+      g.push_self
+      g.push_const :PatternMismatch
+      construct(g)
+      g.send :new, 1
+      g.allow_private
+      g.send :raise, 1
+      g.pop
+
+      done.set!
+    end
+
+    # local names bound by this pattern
+    def local_names
+      []
+    end
+
+    # number of locals
+    def locals
+      local_names.size
+    end
+
+    # number of bindings
+    def bindings
+      locals
+    end
+
+    # test if a pattern matches a value
+    def ===(v)
+      singleton_class.dynamic_method(:===) do |g|
+        g.total_args = g.required_args = g.local_count = 1
+        g.push_local(0)
+        matches?(g)
+        g.ret
+      end
+
+      __send__ :===, v
+    end
+
+    def to_node
+      Atomy::AST::Pattern.new(0, self)
+    end
+  end
+
+  # include all pattern classes
+  path = File.expand_path("../patterns", __FILE__)
+
+  Dir["#{path}/*.rb"].sort.each do |f|
+    require path + "/#{File.basename f}"
+  end
+
+  class Atomy::AST::Node
+    def pattern
+      raise "unknown pattern: #{inspect}"
+    end
+  end
+
+  class Atomy::AST::Variable
+    def pattern
+      if @name == "_"
+        Any.new
+      else
+        Named.new(@name, Any.new)
+      end
+    end
+  end
+
+  class Atomy::AST::Primitive
+    def pattern
+      Match.new(@value)
+    end
+  end
+
+  class Atomy::AST::List
+    def pattern
+      List.new(@elements.collect(&:to_pattern))
+    end
+  end
+
+  class Atomy::AST::Constant
+    def pattern
+      Constant.new(self)
+    end
+  end
+
+  class Atomy::AST::ScopedConstant
+    def pattern
+      Constant.new(self)
+    end
+  end
+
+  class Atomy::AST::ToplevelConstant
+    def pattern
+      Constant.new(self)
+    end
+  end
+
+  class Atomy::AST::BinarySend
+    def pattern
+      case @operator
+      when "."
+        HeadTail.new(@lhs.to_pattern, @rhs.to_pattern)
+      when "="
+        Default.new(@lhs.to_pattern, @rhs)
+      when "?"
+        Predicate.new(@private ? Any.new : @lhs.to_pattern, @rhs)
+      end
+    end
+  end
+
+  class Atomy::AST::Assign
+    def pattern
+      Default.new(@lhs.to_pattern, @rhs)
+    end
+  end
+
+  class Atomy::AST::BlockPass
+    def pattern
+      BlockPass.new(@body.to_pattern)
+    end
+  end
+
+  class Atomy::AST::Quote
+    def pattern
+      Quote.new(@expression)
+    end
+  end
+
+  class Atomy::AST::Block
+    def pattern
+      SingletonClass.new(self)
+    end
+  end
+
+  class Atomy::AST::GlobalVariable
+    def pattern
+      NamedGlobal.new(@identifier)
+    end
+  end
+
+  class Atomy::AST::InstanceVariable
+    def pattern
+      NamedInstance.new(@identifier)
+    end
+  end
+
+  class Atomy::AST::ClassVariable
+    def pattern
+      NamedClass.new(@identifier)
+    end
+  end
+
+  class Atomy::AST::Unary
+    def pattern
+      case @operator
+      when "$"
+        NamedGlobal.new(@receiver.name)
+      when "@"
+        case @receiver
+        when Atomy::AST::Unary
+          NamedClass.new(@receiver.receiver.name)
+        else
+          NamedInstance.new(@receiver.name)
+        end
+      when "%"
+        RuntimeClass.new(@receiver, nil)
+      when "&"
+        BlockPass.new(@receiver.to_pattern)
+      when "*"
+        Splat.new(@receiver.to_pattern)
+      end
+    end
+  end
+
+  class Atomy::AST::Splat
+    def pattern
+      Splat.new(@value.to_pattern)
+    end
+  end
+
+  class Atomy::AST::String
+    def pattern
+      Match.new(@value)
+    end
+  end
+
+  class Atomy::AST::Particle
+    def pattern
+      Particle.new(@name.to_sym) # TODO: other forms
+    end
+  end
+
+  class Atomy::AST::Send
+    def pattern
+      if @block
+        Named.new(@method_name, @block.contents[0].to_pattern)
+      else
+        Attribute.new(@receiver, @method_name, @arguments)
+      end
+    end
+  end
+
+  class Atomy::AST::QuasiQuote
+    def pattern
+      QuasiQuote.new(self)
+    end
+  end
+end