rupture 0.0.0 → 0.1.0

data/lib/rupture/sequence.rb

@@ -0,0 +1,274 @@
+module Rupture
+  module Sequence
+    def first
+      seq.first
+    end
+
+    def rest
+      seq.rest
+    end
+
+    def next
+      rest.seq
+    end
+
+    def second
+      rest.first
+    end
+
+    def empty?
+      not seq
+    end
+
+    def not_empty
+      self if seq
+    end
+
+    def count
+      F.loop(0, self) do |recur, i, s|
+        if s.empty?
+          i
+        elsif s.respond_to?(:size)
+          s.size + i
+        else
+          recur[i.inc, s.rest]
+        end
+      end
+    end
+
+    def inspect
+      "(#{to_a.collect(&:inspect).join(' ')})"
+    end
+
+    def conj(item)
+      F.cons(item, self)
+    end
+
+    def into(coll)
+      coll.seq.reduce(:conj, self)
+    end
+
+    def reverse
+      Seq.empty.into(self)
+    end
+
+    def take(n)
+      F.lazy_seq do
+        if n.pos? and s = seq
+          F.cons(s.first, s.rest.take(n.dec))
+        end
+      end
+    end
+
+    def drop(n)
+      F.lazy_seq do
+        F.loop(n, seq) do |recur, n, s|
+          if s and n.pos?
+            recur[n.dec, s.next]
+          else
+            s
+          end
+        end
+      end
+    end
+
+    def take_last(n)
+      F.loop(seq, drop(n).seq) do |recur, s, lead|
+        if lead
+          recur[s.next, lead.next]
+        else
+          s || Seq.empty
+        end
+      end
+    end
+
+    def drop_last(n)
+      F.map(self, drop(n)) {|x,_| x}
+    end
+
+    def last
+      take_last(1).first
+    end
+
+    def split_at(n)
+      [take(n), drop(n)]
+    end
+
+    def take_while(p = nil, &pred)
+      pred ||= p
+      F.lazy_seq do
+        if s = seq
+          i = s.first
+          F.cons(i, s.rest.take_while(pred)) if pred[i]
+        end
+      end
+    end
+
+    def drop_while(p = nil, &pred)
+      pred ||= p
+      F.lazy_seq do
+        F.loop(seq) do |recur, s|
+          if s and pred[s.first]
+            recur[s.next]
+          else
+            s
+          end
+        end
+      end
+    end
+
+    def split_with(p = nil, &pred)
+      pred ||= p
+      [take_while(pred), drop_while(pred)]
+    end
+
+    def filter(p = nil, &pred)
+      pred ||= p
+      F.lazy_seq do
+        if s = seq
+          i = s.first
+          tail = s.rest.filter(pred)
+          pred[i] ? F.cons(i, tail) : tail
+        end
+      end
+    end
+
+    def remove(p = nil, &pred)
+      pred ||= p
+      filter(pred.complement)
+    end
+
+    def separate(p = nil, &pred)
+      pred ||= p
+      [filter(pred), remove(pred)]
+    end
+
+    def sequential?
+      true
+    end
+
+    def flatten
+      sequential = lambda {|x| x.class <= Seq or x.class == Array}
+      tree_seq(sequential, :seq).remove(sequential)
+    end
+
+    def map(f = nil, &fn)
+      fn ||= f
+      F.map(fn, self)
+    end
+
+    def concat(*colls)
+      F.concat(self, *colls)
+    end
+
+    def mapcat(f = nil, &fn)
+      fn ||= f
+      F.mapcat(fn, self)
+    end
+
+    def reduce(*args, &fn)
+      fn ||= args.shift
+      Utils.verify_args(args, 0, 1)
+
+      if s = seq
+        inject(*args, &fn)
+      elsif args.size == 1
+        args.first
+      else
+        fn[] if fn.arity == -1
+      end
+    end
+
+    def foldr(*args, &fn)
+      fn ||= args.shift
+      reverse.reduce(*args) {|a,b| fn[b,a]}
+    end
+
+    def tree_seq(branch, children, &f)
+      branch   ||= f
+      children ||= f
+      walk = lambda do |node|
+        F.lazy_seq do
+          rest = children[node].mapcat(walk) if branch[node]
+          F.cons(node, rest)
+        end
+      end
+      walk[self]
+    end
+
+    def every?(p = nil, &pred)
+      pred ||= p || F[:identity]
+      all?(&pred)
+    end
+
+    def some(f = nil, &fn)
+      fn ||= f || F[:identity]
+      F.loop(seq) do |recur, s|
+        if s
+          if val = fn[s.first]
+            val
+          else
+            recur[s.next]
+          end
+        end
+      end
+    end
+
+    def nth(n)
+      drop(n.dec).first
+    end
+
+    def partition(n, step = n, pad = nil)
+      F.lazy_seq do
+        if s = seq
+          p = take(n)
+          if n == p.count
+            F.cons(p, drop(step).partition(n, step, pad))
+          elsif pad
+            F.cons(p.concat(pad).take(n), nil)
+          else
+            nil
+          end
+        end
+      end
+    end
+
+    def partition_all(n, step = n)
+      partition(n, step, [])
+    end
+
+    def partition_by(f = nil, &fn)
+      fn ||= f
+      F.lazy_seq do
+        if s = seq
+          head = s.first
+          val  = fn[head]
+          run = F.cons(head, s.rest.take_while {|i| val == fn[i]})
+          F.cons(run, s.drop(run.count).partition_by(fn))
+        end
+      end
+    end
+
+    def partition_between(f = nil, &fn)
+      fn ||= f
+      F.lazy_seq do
+        if s = seq
+          run = F.cons(s.first, s.partition(2,1).take_while {|i| not fn[*i]}.map(:second))
+          F.cons(run, s.drop(run.count).partition_between(fn))
+        end
+      end
+    end
+
+    def doall(n = nil)
+      if n
+        loop(n, seq) do |recur, n, s|
+          recur[n.dec, s.next] if s and n.pos?
+        end
+      else
+        loop(seq) do |recur, s|
+          recur[s.next] if s
+        end
+      end
+    end
+  end
+end

data/lib/rupture/symbol.rb

@@ -0,0 +1,32 @@
+require 'forwardable'
+
+class Rupture::Symbol # Use for symbols
+  extend Forwardable
+  def_delegators :@symbol, :to_s, :name, :namespace
+
+  def initialize(*args)
+    Utils.verify_args(args, 1, 2)
+    @symbol = args.join("/").to_sym
+  end
+
+  alias inspect to_s
+end
+
+class Symbol # Use for keywords
+  def name
+    parse_namespace unless @name
+    @name
+  end
+
+  def namespace
+    parse_namespace unless @name
+    @namespace
+  end
+
+private
+
+  def parse_namespace
+    @name, *ns = to_s.split('/').reverse
+    @namespace = ns.join('/')
+  end
+end

data/lib/rupture/utils.rb

@@ -0,0 +1,7 @@
+module Rupture
+  module Utils
+    def self.verify_args(args, *sizes)
+      raise ArgumentError, "wrong number of arguments (#{args.size} for 2)" unless sizes.include?(args.size)
+    end
+  end
+end

data/lib/rupture.rb

@@ -0,0 +1,20 @@
+module Rupture; end
+
+require 'rupture/core_ext'
+require 'rupture/rails_ext'
+require 'rupture/utils'
+require 'rupture/function'
+require 'rupture/fn'
+require 'rupture/lookup'
+require 'rupture/symbol'
+require 'rupture/meta'
+require 'rupture/sequence'
+require 'rupture/seq'
+require 'rupture/lazy_seq'
+require 'rupture/cons'
+require 'rupture/array_seq'
+require 'rupture/list'
+
+F = Rupture::Function
+
+Object.send(:include, Rupture::Meta)

data/rupture.gemspec

@@ -5,31 +5,53 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rupture}
-  s.version = "0.0.0"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Justin Balthrop"]
-  s.date = %q{2011-07-19}
+  s.date = %q{2011-09-09}
   s.description = %q{Clojure sequence functions for Ruby.}
   s.email = %q{code@justinbalthrop.com}
   s.extra_rdoc_files = [
     "LICENSE",
-    "README.rdoc"
+    "README.md"
   ]
   s.files = [
     "LICENSE",
-    "README.rdoc",
+    "README.md",
     "Rakefile",
     "VERSION",
+    "init.rb",
+    "lib/rupture.rb",
+    "lib/rupture/array_seq.rb",
+    "lib/rupture/cons.rb",
+    "lib/rupture/core_ext.rb",
+    "lib/rupture/fn.rb",
+    "lib/rupture/function.rb",
+    "lib/rupture/lazy_seq.rb",
+    "lib/rupture/list.rb",
+    "lib/rupture/lookup.rb",
+    "lib/rupture/meta.rb",
+    "lib/rupture/rails_ext.rb",
+    "lib/rupture/reader.rb",
     "lib/rupture/seq.rb",
-    "rupture.gemspec"
+    "lib/rupture/sequence.rb",
+    "lib/rupture/symbol.rb",
+    "lib/rupture/utils.rb",
+    "rupture.gemspec",
+    "test/fn_test.rb",
+    "test/list_test.rb",
+    "test/meta_test.rb",
+    "test/seq_test.rb",
+    "test/test_helper.rb"
   ]
   s.homepage = %q{http://github.com/flatland/rupture}
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.5.2}
+  s.rubygems_version = %q{1.3.7}
   s.summary = %q{Clojure sequence functions for Ruby.}
 
   if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then

data/test/fn_test.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class FnTest < Test::Unit::TestCase
+  should "identity" do
+    assert_equal [1,2,3].seq, [1,2,3].seq.map(F[:identity])
+  end
+
+  should "juxt" do
+    assert_equal [[2,0],[3,1],[4,2]].seq, [1,2,3].seq.map(F.juxt(:inc, :dec))
+  end
+
+  # should "apply" do
+  #   assert_equal [1,2,3,4,5,6].seq, F[:concat].apply([1],[2],[[3,4],[5,6]])
+  # end
+
+  should "use hash as fn" do
+    assert_equal [1, 2, 3, nil].seq, [:foo, :bar, :baz, :bam].seq.map({:foo => 1, :bar => 2, :baz => 3})
+  end
+
+  should "use set and sorted set as fn" do
+    assert_equal [:foo, 2, nil, :baz, nil].seq, [:foo, 2, :bar, :baz, :bam].seq.map(Set[:foo, 2, :baz])
+    assert_equal [:foo, 2, nil, :baz, nil].seq, [:foo, 2, :bar, :baz, :bam].seq.map(SortedSet[:foo, 2, :baz])
+  end
+
+  should "use array as fn" do
+    assert_equal [:foo, :bar, nil, :baz, :bar].seq, [0, 1, 3, 2, 1].seq.map([:foo, :bar, :baz])
+  end
+
+  should "use symbol lookup as fn" do
+    assert_equal [3, nil, 7, nil].seq, [{:foo => 3}, {}, {:foo => 7}, {:bar => 1}].seq.map(:foo.lookup)
+    assert_equal [3, nil, 7, nil].seq, [{:foo => 3}, {}, {:foo => 7}, {:bar => 1}].seq.map(~:foo)
+  end
+
+  should "use string lookup as fn" do
+    assert_equal [3, nil, 7, nil].seq, [{'foo' => 3}, {}, {'foo' => 7}, {'bar' => 1}].seq.map('foo'.lookup)
+  end
+
+  should "use numeric lookup as fn" do
+    assert_equal [3, nil, 7, nil].seq, [[0,3], {}, {1 => 7}, {'bar' => 1}].seq.map(1.lookup)
+  end
+end

data/test/list_test.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ListTest < Test::Unit::TestCase
+  should "act like a seq" do
+    list = F.list(1, 2, 3, 4)
+    assert_equal list.count,                4
+    assert_equal list.first,                1
+    assert_equal list.rest.next.rest.first, 4
+    assert_nil   list.next.next.next.next
+  end
+
+  should "count quickly" do
+    list = F.list(1, 2, 3, 4)
+    def list.each
+      raise "Tried to compute count by doing O(N) walk"
+    end
+
+    assert_equal list.count, 4
+  end
+end

data/test/meta_test.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class MetaTest < Test::Unit::TestCase
+  should "have meta data" do
+    a = "foo"
+
+    assert_equal({}, a.meta)
+
+    a.meta[:foo] = 1
+    a.meta[:bar] = 2
+    assert_equal({:foo => 1, :bar => 2}, a.meta)
+
+    b = a.clone
+    b.meta[:foo] = 3
+    assert_equal({:foo => 1, :bar => 2}, a.meta)
+    assert_equal({:foo => 3, :bar => 2}, b.meta)
+  end
+
+  should "change meta using with_meta" do
+    a = [1,2,3]
+    assert_equal({}, a.meta)
+
+    b = a.with_meta(:foo => 1)
+    assert_equal({:foo => 1}, b.meta)
+
+    c = b.with_meta(:baz => 1)
+    assert_equal({:baz => 1}, c.meta)
+  end
+
+  should "change meta using vary_meta" do
+    a = [1,2,3]
+    assert_equal({}, a.meta)
+
+    b = a.vary_meta do |m|
+      m[:foo] = 1
+      m
+    end
+    assert_equal({:foo => 1}, b.meta)
+
+    c = b.vary_meta(:merge, :bar => 3)
+    assert_equal({:foo => 1, :bar => 3}, c.meta)
+  end
+end