rouge-lang 0.0.4 → 0.0.5

data/README.md

@@ -8,19 +8,14 @@ Why?
 * Quick boot time (currently around 0.1s).
 * Ruby's gems tend to be modern with decent APIs.
 
-You can try a Rouge REPL online at **[Try Rouge](http://try.rouge.io)**.
-
-Rouge is not yet mature enough to have an installer or distributions.  Just
-clone the source and run the `rouge` script to start:
+You can try a Rouge REPL online at **[Try Rouge](http://try.rouge.io)**, or install the gem to get the local REPL:
 
 ``` bash
-git clone git://github.com/unnali/rouge
-cd rouge
-bundle install
-bin/rouge
+gem install rouge-lang
+rouge
 ```
 
-You'll see the `user=>` prompt.  Enjoy!  (Expect plenty of stack traces.)
+You'll see the `user=>` prompt.  Enjoy!
 
 You can discuss on Google Groups' [rouge-talk](https://groups.google.com/forum/#!forum/rouge-talk),
 or on `#rouge` on Freenode.
@@ -54,7 +49,7 @@ salient features:
 What about in Rails?
 
 ```
-$ r c -- -I../rouge/lib -rrouge
+$ rails console -- -rrouge
 Loading development environment (Rails 3.2.6)
 1.9.3p194 :002 > Rouge::REPL.repl []
 user=> (.where ruby/Content {:id 1})

data/lib/boot.rg

@@ -31,7 +31,7 @@
   `(Rouge.Seq.Lazy. (fn [] ~@body)))
 
 (defn reduce [f coll]
-  (.inject (.to_a coll) | f))
+  (.inject (.to_a (seq coll)) | f))
 
 (defmacro when [cond & body]
   `(if ~cond
@@ -42,7 +42,8 @@
   (Rouge.Seq.Cons. head tail))
 
 (defn count [coll]
-  (.count coll))
+  (let [s (seq coll)]
+    (if s (.count s) 0)))
 
 (defn = [a b]
   (.== a b))
@@ -72,10 +73,11 @@
 
 (defn map [f coll]
   (lazy-seq
-    (if (empty? coll)
-      nil
-      (let [[hd & tl] coll]
-        (cons (f hd) (map f tl))))))
+    (let [s (seq coll)]
+      (if (empty? s)
+        nil
+        (let [[hd & tl] s]
+          (cons (f hd) (map f tl)))))))
 
 (defn str [& args]
   (let [args (.to_a (map .to_s args))]
@@ -94,6 +96,9 @@
 (defn class [object]
   (.class object))
 
+(defn class? [obj class]
+  (.is_a? obj class))
+
 (defn sequential? [coll]
   (or (.is_a? coll Rouge.Seq.ISeq)
       (.is_a? coll Array)))
@@ -363,6 +368,84 @@
       .to_a
       (.sort_by | keyfn)))
 
+(defn to-array [coll]
+  "Returns an array of (seq coll)."
+  (.to_a (seq coll)))
+
+(defmacro cond
+  ([])
+  ([test result & rest]
+   `(if ~test ~result (cond ~@rest))))
+
+(ns ^{:doc "Implemenations of functions from clojure.string."}
+  rouge.string
+  (:use rouge.core ruby))
+
+(defn blank? [s]
+  "Returns true if s is falsy, empty, or contains only whitespace."
+  (if s
+    (if (or (= (.length s) 0)
+      true
+      (if (.all? (to-array s) | #(.match #"\s" %))
+        true
+        false))
+    false)))
+
+(defn lower-case [s]
+  "Converts the characters in string s to all lower-case."
+  (.downcase s))
+
+(defn upper-case [s]
+  "Converts the string s to all upper-case."
+  (.upcase s))
+
+(defn capitalize [s]
+  "Converts a string to all lower-case with the first character capitalized"
+  (-> s .downcase .capitalize))
+
+(defn trim [s]
+  "Removes all leading and trailing whitespace characters from the string s."
+  (.strip s))
+
+(defn ltrim [s]
+  "Removes all leading whitespace characters from the string s."
+  (.lstrip s))
+
+(defn rtrim [s]
+  "Removes all trailing whitespace characters from the string s."
+  (.rstrip s))
+
+(defn trim-newline [s]
+  "Removes all trailing newline characters from the string s."
+  (.sub s #"(\n|\r)*$" ""))
+
+(defn split [s delimiter]
+  "Splits a string s in to substrings based on delimiter. The delimiter may be
+  either another string or regular expression."
+  (.split s delimiter))
+
+(defn split-lines [s]
+  "Split the string s in to substrings at new lines."
+  (.split s #"\n|\r"))
+
+(defn join [separator coll]
+  "Returns a string in which all elements in coll are joined by the separator."
+  (.join (to-array coll) separator))
+
+(defn reverse [s]
+  "Returns the string s with it's characters in reverse order."
+  (.reverse s))
+
+;; TODO
+#_(defn escape [s cmap])
+
+;; TODO
+#_(defn replace [s match replacement])
+
+;; TODO
+#_(defn replace-first [s match replacement])
+
+
 (ns rouge.test
   (:use rouge.core ruby))
 

data/lib/rouge.rb

@@ -9,7 +9,7 @@ module Rouge; end
 start = Time.now
 Rouge.define_singleton_method :start, lambda {start}
 
-class << Rouge
+module Rouge
   require 'rouge/version'
   require 'rouge/wrappers'
   require 'rouge/symbol'
@@ -19,36 +19,38 @@ class << Rouge
   require 'rouge/context'
   require 'rouge/repl'
 
-  def print(form, out)
+  def self.print(form, out)
     Rouge::Printer.print form, out
   end
 
-  def [](ns)
+  def self.[](ns)
     Rouge::Namespace[ns]
   end
 
-  def boot!
+  def self.boot!
     return if @booted
     @booted = true
 
+    builtin = Rouge[:"rouge.builtin"]
+
     core = Rouge[:"rouge.core"]
-    core.refer Rouge[:"rouge.builtin"]
+    core.refer builtin
 
     user = Rouge[:user]
-    user.refer Rouge[:"rouge.builtin"]
-    user.refer Rouge[:"rouge.core"]
+    user.refer builtin
+    user.refer core
     user.refer Rouge[:ruby]
 
     Rouge::Context.new(user).readeval(
         File.read(Rouge.relative_to_lib('boot.rg')))
   end
 
-  def repl(argv)
+  def self.repl(argv)
     boot!
     Rouge::REPL.repl(argv)
   end
 
-  def relative_to_lib name
+  def self.relative_to_lib name
     File.join(File.dirname(File.absolute_path(__FILE__)), name)
   end
 end

data/lib/rouge/seq.rb

@@ -1,12 +1,30 @@
 # encoding: utf-8
 
+# Functions, clases and modules concerning the `seq' sequence abstraction.
 module Rouge::Seq
+  # An empty seq.
   Empty = Object.new
 
+  # A sequence consisting of a head (element) and tail (another sequence).
+  # Filled out below after ASeq's definition.
   class Cons; end
 
+  # A module purely to indicate that this is a seqable type.  Any class
+  # including ISeq should define a #seq method.
   module ISeq; end
 
+  # A partial implementation of ISeq.  You supply #first and #next, it gives:
+  #
+  #  - #cons
+  #  - #inspect
+  #  - #to_s
+  #  - #seq
+  #  - #length (#count)
+  #  - #[]
+  #  - #==
+  #  - #each
+  #  - #map
+  #  - #to_a
   module ASeq
     include ISeq
 
@@ -22,41 +40,41 @@ module Rouge::Seq
     def next; raise NotImplementedError; end
 
     def more
-      s = self.next
-      if s.nil?
+      nseq = self.next
+      if nseq.nil?
         Empty
       else
-        s
+        nseq
       end
     end
 
-    def cons(o)
-      Cons.new(o, self)
+    def cons(head)
+      Cons.new(head, self)
     end
 
     def length
-      l = 0
+      len = 0
       cursor = self
 
       while cursor != Empty
-        l += 1
+        len += 1
         cursor = cursor.more
       end
 
-      l
+      len
     end
 
     alias count length
 
-    def [](i)
-      return to_a[i] if i.is_a? Range
+    def [](idx)
+      return to_a[idx] if idx.is_a? Range
 
       cursor = self
 
-      i += self.length if i < 0
+      idx += self.length if idx < 0
 
-      while i > 0
-        i -= 1
+      while idx > 0
+        idx -= 1
         cursor = cursor.more
         return nil if cursor == Empty
       end
@@ -65,8 +83,15 @@ module Rouge::Seq
     end
 
     def ==(seq)
-      (seq.is_a?(ISeq) and self.to_a == seq.to_a) or
-        (seq.is_a?(::Array) and self.to_a == seq)
+      if seq.is_a?(ISeq)
+        return self.to_a == seq.to_a
+      end
+
+      if seq.is_a?(::Array)
+        return self.to_a == seq
+      end
+
+      false
     end
 
     def each(&block)
@@ -86,9 +111,9 @@ module Rouge::Seq
     def map(&block)
       return self.enum_for(:map) if block.nil?
 
-      r = []
-      self.each {|e| r << block.call(e)}
-      r
+      result = []
+      self.each {|elem| result << block.call(elem)}
+      result
     end
 
     def to_a
@@ -96,10 +121,6 @@ module Rouge::Seq
       self.each {|e| r << e}
       r
     end
-
-    def map(&block)
-      Cons[*to_a.map(&block)]
-    end
   end
 
   class << Empty
@@ -135,10 +156,11 @@ module Rouge::Seq
     def next; Rouge::Seq.seq @tail; end
 
     def self.[](*elements)
-      return Empty if elements.length.zero?
+      length = elements.length
+      return Empty if length.zero?
 
       head = nil
-      (elements.length - 1).downto(0).each do |i|
+      (length - 1).downto(0).each do |i|
         head = new(elements[i], head.freeze)
       end
 
@@ -148,24 +170,27 @@ module Rouge::Seq
     attr_reader :head, :tail
   end
 
+  # A seq over a Ruby Array.
   class Array
     include ASeq
 
-    def initialize(array, i)
-      @array, @i = array, i
+    def initialize(array, idx)
+      @array, @idx = array, idx
     end
 
     def first
-      @array[@i]
+      @array[@idx]
     end
 
     def next
-      if @i + 1 < @array.length
-        Array.new(@array, @i + 1)
+      if @idx + 1 < @array.length
+        Array.new(@array, @idx + 1)
       end
     end
   end
 
+  # A lazy seq; contains the body (thunk) which is a lambda to get the "real"
+  # seq.  Once evaluated (realised), the result is cached.
   class Lazy
     include ISeq
 
@@ -179,6 +204,7 @@ module Rouge::Seq
         @result
       else
         @result = Rouge::Seq.seq(@body.call) || Empty
+        @body = nil
         @realized = true
         @result
       end
@@ -196,6 +222,8 @@ module Rouge::Seq
     def to_s; seq.to_s; end
   end
 
+  # An error thrown when we try to do a seq operation on something that's not
+  # seqable.
   UnknownSeqError = Class.new(StandardError)
 
   def self.seq(form)
@@ -212,6 +240,8 @@ module Rouge::Seq
       end
     when Enumerator
       seq(form.to_a)
+    when String
+      seq(form.chars)
     else
       raise UnknownSeqError, form.inspect
     end

data/lib/rouge/version.rb

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

data/spec/core_spec.rg

@@ -37,7 +37,8 @@
 (testing "seq"
   (is (.nil? (seq ())))
   (is (.nil? (seq nil)))
-  (is (.nil? (seq []))))
+  (is (.nil? (seq [])))
+  (is (.nil? (seq ""))))
 
 (testing "first"
   (is (.nil? (first nil)))
@@ -90,6 +91,7 @@
 (testing "map"
   (is (= Rouge.Seq.Lazy (class (map inc [1 2 3]))))
   (is (= '(2 3 4) (map inc [1 2 3])))
+  (is (= '("A" "B" "C") (map .upcase "abc")))
   (is (= 1
          (let [q (atom 0)
                lazy (map #(do (swap! q inc) (inc %)) [1 2 3])]
@@ -123,4 +125,30 @@
                    [hd & tl] (map #(do (swap! q inc) (inc %)) [1 2 3])]
                @q)))))
 
+(testing "cond"
+  (is (= 1 (cond
+             :else 1)))
+  (is (= 1 (cond
+             false 2
+             nil 3
+             true 1)))
+  (is (nil? (cond)))
+  (is (nil? (cond
+              false 1
+              nil 2)))
+  (is (= 1 (let [q (atom 0)]
+             (is (= :ok (cond
+                          (swap! q inc) :ok
+                          (swap! q inc) :bad
+                          (swap! q inc) :very_bad)))
+             @q)))
+  (is (= 2 (let [q (atom 0)]
+             (is (= :ok (cond
+                          (do
+                            (swap! q inc)
+                            nil) :bad
+                          (swap! q inc) :ok
+                          (swap! q inc) :very_bad)))
+             @q))))
+
 ; vim: set ft=clojure:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rouge-lang
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-03 00:00:00.000000000 Z
+date: 2012-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake