rouge-lang 0.0.11 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7c04c0679c815a8252a0cb225c1b2e6b40bfa4f2
-  data.tar.gz: 6853310b4bc56abdff3665d05d3c44ce89a09d30
+  metadata.gz: e1e27ba25fbbb2222935a382e5415a8e294e2fba
+  data.tar.gz: 90af1a227a44d3356f2b3f4f42536f39947b9dcf
 SHA512:
-  metadata.gz: 7b9ea934f1bfde5572227dff993dcae0e4b99ee34339ab2a5a1f62bf54cb01767c8cc526180ec370166e720e634ec46e5f0984ce08721656dd12ea8b28861ac9
-  data.tar.gz: ae0a574e874b488331d9df9107d977cd6155aa015a036f17dd53a88702c0c73231802bc4627d1a331bb369a2579ab3011a8dd814d5a51b8729f068dd0c8ea96d
+  metadata.gz: 531cc48c8807f33ff2968e92d21ad75bbd8ee6d992c701528dc397f49cd54f40f0774384013156993fb939d906b75e94ee6487a97f46a09d463262866dd83591
+  data.tar.gz: bcf7963675049fac6c11ce0e38444c18c53bce272c36506f8e2f8cedc676c7e3c59ee46a75763dda97fc9a0db0da7db0c3fe42d5143918a91f17c9a70b5c8ddc

data/.travis.yml

@@ -1,3 +1,7 @@
 rvm:
- - 1.9.2
- - 1.9.3
+  - 1.9.2
+  - 1.9.3
+  - rbx-19mode
+matrix:
+  allow_failures:
+    - rvm: rbx-19mode

data/README.md

@@ -1,4 +1,4 @@
-# Rouge [![Build Status](https://secure.travis-ci.org/unnali/rouge.png)](http://travis-ci.org/unnali/rouge)
+# Rouge [![Build Status](https://secure.travis-ci.org/rouge-lang/rouge.png)](http://travis-ci.org/rouge-lang/rouge)
 
 **Ruby + Clojure = Rouge.**
 
@@ -22,7 +22,7 @@ or on `#rouge` on Freenode.
 
 ## example
 
-See [boot.rg](https://github.com/unnali/rouge/blob/master/lib/boot.rg),
+See [boot.rg](https://github.com/rouge-lang/rouge/blob/master/lib/boot.rg),
 [em-rg](https://github.com/unnali/em-rg),
 [mechanize-rg](https://github.com/unnali/mechanize-rg), but to demonstrate
 salient features:
@@ -60,7 +60,7 @@ user=>
 
 ## TODO
 
-See [TODO](https://github.com/unnali/rouge/blob/master/misc/TODO), but big ones
+See [TODO](https://github.com/rouge-lang/rouge/blob/master/misc/TODO), but big ones
 include:
 
 * making seqs nicer
@@ -82,12 +82,15 @@ include:
 
 Original author: [Arlen Christian Mart Cuss](https://github.com/unnali).
 
+Committers:
+
+* [Joel Holdbrooks](https://github.com/noprompt)
+
 Unreserved thanks to the following people for their contributions.
 
 * [Russell Whitaker](https://github.com/russellwhitaker)
 * [Misha Moroshko](https://github.com/moroshko)
 * [Anthony Grimes](https://github.com/Raynes)
-* [Joel Holdbrooks](https://github.com/noprompt)
 
 ## copyright and licensing
 

data/lib/rouge/context.rb

@@ -5,11 +5,17 @@ require 'rouge/namespace'
 class Rouge::Context
   class BindingNotFoundError < StandardError; end
   class BadBindingError < StandardError; end
+
   class ChangeContextException < Exception
-    def initialize(context); @context = context; end
     attr_reader :context
+
+    def initialize(context)
+      @context = context
+    end
   end
 
+  attr_reader :ns
+
   def initialize(parent_or_ns)
     case parent_or_ns
     when Rouge::Namespace
@@ -18,6 +24,7 @@ class Rouge::Context
       @parent = parent_or_ns
       @ns = @parent.ns
     end
+
     @table = {}
   end
 
@@ -47,8 +54,7 @@ class Rouge::Context
     elsif @parent
       @parent.set_lexical key, value
     else
-      raise BindingNotFoundError,
-          "setting #{key} to #{value.inspect}"
+      raise BindingNotFoundError, "setting #{key} to #{value.inspect}"
     end
   end
 
@@ -56,7 +62,7 @@ class Rouge::Context
     @table.keys + (@parent ? @parent.lexical_keys : [])
   end
 
-  #   This readeval post-processes the backtrace.  Accordingly, it should only
+  # This readeval post-processes the backtrace.  Accordingly, it should only
   # be called by consumers, and never by Rouge internally itself, lest it
   # catches an exception and processes the backtrace too early.
   def readeval(input)
@@ -129,8 +135,6 @@ class Rouge::Context
     end
   end
 
-  attr_reader :ns
-
   private
 
   def eval_symbol(form)
@@ -197,10 +201,9 @@ class Rouge::Context
           default
         end
       else
-        raise(
-          ArgumentError,
+        raise ArgumentError,
           "Wrong number of args (#{num_args}) passed to " \
-            "ruby/Symbol #{fun.inspect}")
+            "ruby/Symbol #{fun.inspect}"
       end
     when Hash
       if num_args == 1 || num_args == 2
@@ -244,6 +247,6 @@ class Rouge::Context
       raise e
     end
   end
-end
+end # class Rouge::Context
 
 # vim: set sw=2 et cc=80:

data/lib/rouge/namespace.rb

@@ -5,21 +5,26 @@ require 'rouge/var'
 require 'rouge/atom'
 
 class Rouge::Namespace
-  @namespaces = {}
-
   class VarNotFoundError < StandardError; end
   class RecursiveNamespaceError < StandardError; end
 
+  attr_reader :name, :refers, :table
+
+  @namespaces = {}
+
   def initialize(name)
+    unless name.is_a? Symbol
+      raise ArgumentError, "bad ns name"
+    end
+
     @name = name
-    raise ArgumentError, "bad ns name" unless @name.is_a? Symbol
-    @table = {}
     @refers = []
+    @table = {}
   end
 
   def inspect
-    "#<Rouge::NS #{@name.inspect}, " \
-    "refers #{@refers.map(&:inspect).join(", ")}>"
+    "#<Rouge::Namespace: @name=#{@name.inspect}, " \
+    "@refers=[#{@refers.map(&:inspect).join(", ")}]>"
   end
 
   def refer(ns)
@@ -27,7 +32,10 @@ class Rouge::Namespace
       raise RecursiveNamespaceError, "#@name will not refer #{ns.name}"
     end
 
-    @refers << ns if not @refers.include? ns
+    unless @refers.include?(ns)
+      @refers << ns
+    end
+
     self
   end
 
@@ -64,31 +72,44 @@ class Rouge::Namespace
     self
   end
 
-  attr_reader :name, :refers
-end
-
-class << Rouge::Namespace
-  def exists?(ns)
-    @namespaces.include? ns
+  # Returns a hash of all namespaces.
+  #
+  # @return [Hash]
+  #
+  # @api public
+  def self.all
+    @namespaces
   end
 
-  def [](ns)
-    r = @namespaces[ns]
-    return r if r
-
-    self[ns] = new(ns)
-    @namespaces[ns] = new(ns)
+  # Returns true if the given namespace ns exists, false otherwise.
+  #
+  # @param [Symbol] ns the namespace to check for
+  #
+  # @return [Boolean]
+  #
+  # @api public
+  def self.exists?(ns)
+    @namespaces.include?(ns)
   end
 
-  def get(ns)
-    @namespaces[ns]
+  def self.[](ns)
+    if exists?(ns)
+      @namespaces[ns]
+    else
+      self[ns] = new(ns)
+      @namespaces[ns] = new(ns)
+    end
   end
 
-  def []=(ns, value)
+  def self.[]=(ns, value)
     @namespaces[ns] = value
   end
 
-  def destroy(ns)
+  def self.get(ns)
+    @namespaces[ns]
+  end
+
+  def self.destroy(ns)
     @namespaces.delete ns
   end
 end
@@ -115,16 +136,30 @@ class Rouge::Namespace::Ruby
   def name
     :ruby
   end
+
+  # Returns the result of calling Object.constants.
+  #
+  # @return [Array<Symbol>] the list of Ruby constants
+  #
+  # @api public
+  #
+  def table
+    Object.constants
+  end
 end
 
+# Create the rouge.builtin namespace.
 ns = Rouge::Namespace[:"rouge.builtin"]
+
 Rouge::Builtins.methods(false).reject {|s| s =~ /^_compile_/}.each do |m|
   ns.set_here m, Rouge::Builtin[Rouge::Builtins.method(m)]
 end
+
 Rouge::Builtins::SYMBOLS.each do |name, val|
   ns.set_here name, val
 end
 
+# Create the ruby namespace.
 Rouge::Namespace[:ruby] = Rouge::Namespace::Ruby.new
 
 # vim: set sw=2 et cc=80:

data/lib/rouge/repl.rb

@@ -17,8 +17,10 @@ module Rouge::REPL
     context = Rouge::Context.new(Rouge[:user])
     count = 0
     chaining = false
+    Readline.completion_proc = Completer.new(context.ns)
 
     while true
+
       if !chaining
         prompt = "#{context.ns.name}=> "
         input = Readline.readline(prompt, true)
@@ -40,19 +42,17 @@ module Rouge::REPL
         chaining = true
         next
       rescue Rouge::Reader::UnexpectedCharacterError => reader_err
-        repl_error.call reader_err
+        repl_error.call(reader_err)
       rescue Rouge::Reader::NumberFormatError => reader_err
-        repl_error.call reader_err
+        repl_error.call(reader_err)
       end
 
       chaining = false
 
       begin
-        form = Rouge::Compiler.compile(
-          context.ns,
-          Set[*context.lexical_keys],
-          form
-        )
+        form = Rouge::Compiler.compile(context.ns,
+                                       Set[*context.lexical_keys],
+                                       form)
 
         result = context.eval(form)
 
@@ -66,13 +66,253 @@ module Rouge::REPL
         context.set_here :"*1", result
       rescue Rouge::Context::ChangeContextException => cce
         context = cce.context
+        # Since completion is context sensitive, we need update the proc
+        # whenever it changes.
+        Readline.completion_proc = Completer.new(context.ns)
         count = 0
       rescue => e
-        repl_error.call e
+        repl_error.call(e)
       end
     end
   end
 
+  module Completer
+    extend self
+
+    # Returns a proc intended to be used with Readline.
+    #
+    # @param [Rouge::Namespace] current_namespace
+    #   the current namespace
+    #
+    # @return [Proc] the completion proc to be used with Readline. The
+    #   returned proc accepts a string and returns an array.
+    #
+    # @api public
+    def new(current_namespace)
+      return lambda do |query|
+        if query.nil? || query.empty?
+          return []
+        end
+
+        list = namespace_items(current_namespace)
+        list << search(query)
+
+        matches = search_list(list.flatten, query)
+
+        # If there's only one match we check if it's a namespace or a Ruby
+        # constant which contains other constants or singleton methods.
+        if matches.length == 1
+          match = matches[0]
+          if Rouge::Namespace.exists?(match)
+            if current_namespace.table.include?(match)
+              matches << "#{match}/"
+            else
+              Readline.completion_append_character = "/"
+            end
+          else
+            if locate_module(match.to_s)
+              Readline.completion_append_character = ""
+            end
+          end
+        else
+          Readline.completion_append_character = ""
+        end
+
+        matches
+      end
+    end
+
+    # Returns a list of constants and singleton method names based on the string
+    # query.
+    #
+    # @param [String] query
+    #   the search string to use
+    #
+    # @return [Array<Symbol,String>] the search results
+    #
+    # @api public
+    def search(query)
+      namespace, lookup = query.split('/', 2)
+      result =
+        case namespace
+        # The ruby namespace requires special handling.
+        when /^[A-Z]/
+          search_ruby(query)
+        when /^ruby/
+          if lookup && lookup.empty?
+            Rouge[:ruby].table.map {|x| "ruby/#{x}" }
+          else
+            search_ruby(lookup).map {|x| "ruby/#{x}" }
+          end
+        else
+          ns = rg_namespaces[namespace.to_sym]
+
+          if ns
+            ns.table.map { |var, _| "#{namespace}/#{var}" }
+          else
+            # Add the current namepace, rouge.builtin, and ruby tables along with
+            # the names of available namespaces in the completion list.
+            list = []
+            list << Rouge[:"rouge.builtin"].table.keys
+            list << :ruby
+            list << Rouge[:ruby].table
+            list << rg_namespaces.keys
+          end
+        end
+
+      search_list(result.flatten, query)
+    end
+
+    # Applies `locate_module` to the string query and returns a list constants
+    # and singleton methods. These results are intended to be filtered in the
+    # `search` method.
+    #
+    # @see Completer.locate_module, Completer.search
+    #
+    # @example
+    #   search_ruby("Rouge") #=> ["Rouge/[]", "Rouge/boot!", ...]
+    #   search_ruby("Rouge.") #=> ["Rouge/[]", "Rouge/boot!", ...]
+    #
+    # @param [String] query
+    #   the search string to use
+    #
+    # @return [Array<Symbol,String>] the search result
+    #
+    # @api public
+    def search_ruby(query)
+      namespace = query.split('/', 2).first
+
+      mod = locate_module(namespace)
+
+      if mod == Object
+        mod.constants
+      else
+        ns = mod.name.gsub('::','.')
+        result = []
+        mod.singleton_methods.each { |sm| result << "#{ns}/#{sm}" }
+        mod.constants.each { |c| result << "#{ns}.#{c}" }
+        result.flatten
+      end
+    end
+
+    # Recursively searches for a Ruby module (includes classes) given by the
+    # string query. The string should contain a Rouge style namespace name for
+    # the module.
+    #
+    # Optionally, a root module can be supplied as the context for the query.
+    # By default this is Object. If no module is found, the method returns nil
+    # or the root.
+    #
+    # Be aware this method *only* returns modules and classes.
+    #
+    # @example
+    #   locate_module("Bil.Bo") #=> Bil::Bo
+    #   locate_module("Ji.Tsu", Nin) #=> Nin::Ji::Tsu
+    #
+    # @param [String] query
+    #   the module (or class) to find
+    #
+    # @param [Module] root
+    #   the optional search context
+    #
+    # @return [Class,Module,nil] the search result
+    #
+    # @api public
+    def locate_module(query, root = Object)
+      head, tail = query.split('.', 2)
+
+      return root unless rg_ruby_module?(head)
+
+      lookup = head.to_sym
+
+      if root.is_a?(Module) && root.constants.include?(lookup)
+        result = root.const_get(lookup)
+
+        return root unless result.is_a?(Module)
+
+        # `query` may have ended with '.'.
+        if tail.nil? || tail.empty?
+          result
+        else
+          locate_module(tail, result)
+        end
+      else
+        root
+      end
+    end
+
+    # Rouge namespaces. Note we do not include the rouge.builtin and ruby
+    # namespaces since we would like built in vars, such as def or let, and top
+    # level Ruby constants to be easily accessible with command line
+    # completion.
+    #
+    # @return [Hash] the filtered namespaces
+    #
+    # @api public
+    def rg_namespaces
+      Rouge::Namespace.all.reject do |key, _|
+        [:"rouge.builtin", :ruby].include?(key)
+      end
+    end
+
+    # Returns true if the provided namespace is included in `rg_namespaces`.
+    #
+    # @see Rouge::REPL::Completer.rg_namespaces
+    #
+    # @param [Rouge::Namespace] x
+    #   the namespace to test
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def rg_namespace?(x)
+      x.is_a?(Rouge::Namespace) && rg_namespaces.keys.include?(x.name)
+    end
+
+    private
+
+    # Returns a list of table keys and refer keys based on the given namespace.
+    #
+    # @param [Rouge::Namespace] ns
+    #   the namespace to use
+    #
+    # @return [Array<Symbol>]
+    #
+    # @api public
+    def namespace_items(ns)
+      list = ns.table.keys
+      refers = ns.refers.select { |ns| rg_namespace?(ns) }
+      list << refers.map { |ns| ns.table.keys }
+    end
+
+    # Returns true if the string query matches a Rouge style Ruby module or
+    # constant name.
+    #
+    # @param [String] query
+    #   the query string to match.
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    def rg_ruby_module?(x)
+      !!/^(?:[A-Z][A-Za-z_]*\.?)+$/.match(x)
+    end
+
+    # Filters a list of items based on a string query.
+    #
+    # @param [Array] list
+    #   the list to filter.
+    #
+    # @param [String] query
+    #   the search string to use.
+    #
+    # @return [Array]
+    #
+    # @api private
+    def search_list(list, query)
+      list.grep(/^#{Regexp.escape(query)}/)
+    end
+  end
 end
 
 # vim: set sw=2 et cc=80:

data/lib/rouge/version.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 module Rouge
-  VERSION = "0.0.11"
+  VERSION = "0.0.12"
 end
 
 # vim: set sw=2 et cc=80:

data/spec/repl_spec.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'rouge'
+
+describe Rouge::REPL do
+  describe "comp" do
+    let(:user) { Rouge[:user].clear }
+    let(:food) { Rouge[:food].clear }
+    let(:comp) { Rouge::REPL::Completer }
+    let(:fake_class_a) { Class.new }
+    let(:fake_class_b) { Class.new }
+
+    before {
+      stub_const("Corn", fake_class_a)
+      stub_const("Corn::Bread", fake_class_b)
+      fake_class_a.define_singleton_method(:pop) {}
+      fake_class_b.define_singleton_method(:toast) {}
+      user.set_here(:pop, "corn")
+      food.set_here(:scrambled, "eggs")
+      user.refer(food)
+    }
+
+    context "#new" do
+      let(:comp) { Rouge::REPL::Completer.new(user) }
+      it { comp.call("u").should include(:user) }
+      it { comp.call("p").should include(:pop) }
+      it { comp.call("s").should include(:scrambled) }
+      it { comp.call("Rouge").should include("Rouge.VERSION") }
+      it { comp.call("ruby/").should include("ruby/RUBY_VERSION") }
+      it { comp.call("ruby/Rouge.").should include("ruby/Rouge.VERSION") }
+    end
+
+    context "#search" do
+      it { comp.search("u").should include(:user) }
+      it { comp.search("r").should include(:ruby) }
+      it { comp.search("d").should include(:def) }
+      it { comp.search("user/").should include("user/pop") }
+      it { comp.search("C").should include(:Corn) }
+      it { comp.search("C").should_not include(:Bread) }
+      it { comp.search("Corn.").should include("Corn.Bread") }
+      it { comp.search("Corn/").should include("Corn/pop") }
+      it { comp.search("Corn.").should_not include("Corn/pop") }
+      it { comp.search("Corn/").should_not include("Corn.Bread") }
+      it { comp.search("ruby/C").should include("ruby/Corn") }
+      it { comp.search("ruby/Corn.").should include("ruby/Corn.Bread") }
+      it { comp.search("ruby/Corn/").should include("ruby/Corn/pop") }
+      it { comp.search("ruby/Corn.Bread/").should include("ruby/Corn.Bread/toast") }
+    end
+
+    context "#search_ruby" do
+      it { comp.search_ruby("B").should include(:Corn) }
+      it { comp.search_ruby("Corn").should include("Corn.Bread") }
+      it { comp.search_ruby("Corn").should include("Corn/pop") }
+      it { comp.search_ruby("Corn.Bread").should include("Corn.Bread/toast") }
+    end
+
+    context "#rg_namespaces" do
+      it { comp.send(:rg_namespaces).should be_an_instance_of(Hash) }
+      it { comp.send(:rg_namespaces).should include(:user) }
+    end
+
+    context "#locate_module" do
+      it { comp.locate_module("R").should eq(Object) }
+      it { comp.locate_module("Rouge").should eq(Rouge) }
+      it { comp.locate_module("Rouge.").should eq(Rouge) }
+      it { comp.locate_module("V", Rouge).should eq(Rouge) }
+      it { comp.locate_module("Rouge..").should eq(Rouge) }
+      it { comp.locate_module("Symbol", Rouge).should eq(Rouge::Symbol) }
+      it { comp.locate_module("Rouge.Symbol").should eq(Rouge::Symbol) }
+      it { comp.locate_module("Rouge.symbol").should eq(Rouge) }
+    end
+  end
+end
+
+# vim: set sw=2 et cc=80:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rouge-lang
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors:
 - Arlen Christian Mart Cuss
@@ -153,6 +153,7 @@ files:
 - spec/namespace_spec.rb
 - spec/printer_spec.rb
 - spec/reader_spec.rb
+- spec/repl_spec.rb
 - spec/rouge_spec.rb
 - spec/seq_spec.rb
 - spec/spec_helper.rb
@@ -192,6 +193,7 @@ test_files:
 - spec/namespace_spec.rb
 - spec/printer_spec.rb
 - spec/reader_spec.rb
+- spec/repl_spec.rb
 - spec/rouge_spec.rb
 - spec/seq_spec.rb
 - spec/spec_helper.rb