atomy 0.1.1 → 0.6.3

data/lib/namespace.rb

@@ -1,236 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,276 +0,0 @@
-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