hammock-ruby 0.0.1.alpha

data/lib/hammock/vector.rb

@@ -0,0 +1,309 @@
+require 'hamster/immutable'
+
+require 'hammock/ipersistent_collection'
+require 'hammock/meta'
+require 'hammock/ifn'
+require 'hammock/ilookup'
+require 'hammock/chunked_seq'
+require 'hammock/iseq'
+
+module Hammock
+  class Vector
+    include Hamster::Immutable
+    include IPersistentCollection
+    include Meta
+    include IFn
+    include ILookup
+    include ISeq
+
+    Undefined = Object.new
+
+    BLOCK_SIZE = 32
+    INDEX_MASK = BLOCK_SIZE - 1
+    BITS_PER_LEVEL = 5
+
+    def self.alloc_from(vec, meta = nil)
+      vec.send(:transform) { @meta = meta }
+    end
+
+    def self.create(coll)
+      if Vector === coll
+        coll
+      else
+        from_array(coll.to_a)
+      end
+    end
+
+    def self.from_array(items, meta=nil)
+      items.reduce(new(meta)) { |vector, item| vector.add(item) }
+    end
+
+    def initialize(meta=nil)
+      @meta = meta
+      @levels = 0
+      @root = []
+      @size = 0
+    end
+
+    def empty?
+      @size == 0
+    end
+    alias null? empty?
+
+    def size
+      @size
+    end
+    alias count size
+    alias length size
+
+    def first
+      get(0)
+    end
+    alias head first
+
+    def last
+      get(-1)
+    end
+
+    def add(item)
+      transform do
+        update_leaf_node(@size, item)
+        @size += 1
+      end
+    end
+    alias cons add
+    alias conj add
+
+    def concat(arraylike)
+      arraylike.to_a.reduce(self) do |v, item|
+        v.add(item)
+      end
+    end
+
+    def set(index, item = Undefined)
+      return set(index, yield(get(index))) if item.equal?(Undefined)
+      raise IndexError if empty? or index == @size
+      raise IndexError if index.abs > @size
+      return set(@size + index, item) if index < 0
+      transform do
+        update_leaf_node(index, item)
+      end
+    end
+
+    def get(index)
+      return nil if empty? or index == @size
+      return nil if index.abs > @size
+      return get(@size + index) if index < 0
+      leaf_node_for(@root, root_index_bits, index)[index & INDEX_MASK]
+    end
+    alias nth get
+
+    def fetch(n, missing=Undefined)
+      unless Integer === n
+        raise "Index must be an Integer. Received #{n.inspect}"
+      end
+      if n >= count
+        if missing == Undefined
+          raise IndexError
+        else
+          missing
+        end
+      else
+        get(n)
+      end
+    end
+    alias val_at fetch
+
+    def call(n, missing=nil)
+      fetch(n, missing)
+    end
+
+    def each(&block)
+      return self unless block_given?
+      traverse_depth_first(&block)
+      nil
+    end
+
+    def map(&block)
+      return self unless block_given?
+      reduce(EmptyVector) { |vector, item| vector.add(yield(item)) }
+    end
+
+    def reduce(memo = Undefined)
+      each do |item|
+        memo = memo.equal?(Undefined) ? item : yield(memo, item)
+      end if block_given?
+      memo unless memo.equal?(Undefined)
+    end
+
+    def empty
+      self.class.new(meta)
+    end
+
+    def eql?(other)
+      return true if other.equal?(self)
+      return false unless instance_of?(other.class) && @size == other.size
+      @root.eql?(other.instance_variable_get(:@root))
+    end
+    alias == eql?
+
+    def to_a
+      ret = []
+      each do |obj|
+        ret << obj
+      end
+      ret
+    end
+
+    def assoc_n(idx, obj)
+      if idx == count
+        add(obj)
+      else
+        set(idx, obj)
+      end
+    end
+
+    alias assoc assoc_n
+
+    def seq
+      return if count == 0
+      ChunkedSeq.new(self, 0, 0)
+    end
+
+    def array_for(i)
+      leaf_node_for(@root, root_index_bits, i)
+    end
+
+    def inspect
+      "[#{self.map(&:inspect).to_a.join(' ')}]"
+    end
+
+    private
+
+    def traverse_depth_first(node = @root, level = @levels, &block)
+      return node.each(&block) if level == 0
+      node.each { |child| traverse_depth_first(child, level - 1, &block) }
+    end
+
+    def leaf_node_for(node, child_index_bits, index)
+      return node if child_index_bits == 0
+      child_index = (index >> child_index_bits) & INDEX_MASK
+      leaf_node_for(node[child_index], child_index_bits - BITS_PER_LEVEL, index)
+    end
+
+    def update_leaf_node(index, item)
+      copy_leaf_node_for(new_root, root_index_bits, index)[index & INDEX_MASK] = item
+    end
+
+    def copy_leaf_node_for(node, child_index_bits, index)
+      return node if child_index_bits == 0
+      child_index = (index >> child_index_bits) & INDEX_MASK
+      if child_node = node[child_index]
+        child_node = child_node.dup
+      else
+        child_node = []
+      end
+      node[child_index] = child_node
+      copy_leaf_node_for(child_node, child_index_bits - BITS_PER_LEVEL, index)
+    end
+
+    def new_root
+      if full?
+        @levels += 1
+        @root = [@root]
+      else
+        @root = @root.dup
+      end
+    end
+
+    def full?
+      (@size >> root_index_bits) > 0
+    end
+
+    def root_index_bits
+      @levels * BITS_PER_LEVEL
+    end
+
+    class SubVector
+      include IPersistentCollection
+      include Meta
+      include IFn
+      include ILookup
+      attr_reader :start_idx, :end_idx, :v
+
+      def self.alloc_from(subvec, meta)
+        new(meta, subvec.v, subvec.start_idx, subvec.end_idx)
+      end
+
+      def initialize(meta, vec, start_idx, end_idx)
+        @meta = meta
+        if SubVector === vec
+          start_idx += vec.start_idx
+          end_idx += vec.end_idx
+          vec = vec.v
+        end
+        @v, @start_idx, @end_idx = vec, start_idx, end_idx
+      end
+
+      def to_a
+        a = @v.to_a
+        a[start_idx..end_idx]
+      end
+
+      def size
+        @end_idx - @start_idx
+      end
+      alias count size
+      alias length size
+
+      def add(obj)
+        self.class.new(meta, v.assoc_n(@end_idx, obj), @start_idx, @end_idx + 1)
+      end
+      alias conj add
+      alias cons add
+
+      def get(i)
+        if (@start_idx + i) >= @end_idx || i < 0
+          raise IndexError, "Index #{i} out of bounds."
+        end
+        return v.nth(@start_idx + i);
+      end
+      alias nth get
+      alias val_at get
+
+      def fetch(n, missing=Undefined)
+        if n >= count
+          if missing == Undefined
+            raise IndexError
+          else
+            missing
+          end
+        else
+          get(n)
+        end
+      end
+
+      def call(n, missing=nil)
+        fetch(n, missing)
+      end
+
+      def assoc_n(i, obj)
+        if (@start_idx + i) > @end_idx
+          raise IndexError, "Index #{i} out of bounds."
+        elsif (@start_idx + i) == @end_idx
+          cons(val)
+        else
+          self.class.new v.assoc_n(@start_idx + i, obj), @start_idx, @end_idx
+        end
+      end
+      alias assoc assoc_n
+
+      def inspect
+        "[#{to_a.map(&:inspect).join(' ')}]"
+      end
+    end
+
+  end
+
+  EmptyVector = Vector.new
+end

data/lib/hammock/version.rb

@@ -0,0 +1,3 @@
+module Hammock
+  VERSION = "0.0.1.alpha"
+end

data/lib/hammock/volatile.rb

@@ -0,0 +1,19 @@
+require 'hammock/ideref'
+
+module Hammock
+  class Volatile
+    include IDeref
+
+    def initialize(val)
+      @value = val
+    end
+
+    def deref
+      @value
+    end
+
+    def reset(newval)
+      @value = newval
+    end
+  end
+end

data/spec/examples/data.hmk

@@ -0,0 +1,4 @@
+(map foo
+     {:foo "bar"
+      :bar 1
+      :quux 1.4})

data/spec/hammock/reader_spec.rb

@@ -0,0 +1,242 @@
+require 'hammock/reader'
+require 'stringio'
+
+describe Hammock::Reader do
+  def read_string(string)
+    io = StringIO.new(string)
+    Hammock::Reader.new.read(io)
+  end
+
+  it "reads a list of numbers" do
+    result = read_string "(1 21 331)"
+    expect(result.to_a).to eq [1, 21, 331]
+  end
+
+  it "reads nested lists of numbers" do
+    result = read_string "(1 (21 331))"
+    expect(result.to_a).to eq [1, Hammock::Sequence.from_array([21, 331])]
+  end
+
+  it "reads bare numbers" do
+    result = read_string "324"
+    expect(result).to eq 324
+  end
+
+  it "reads floats" do
+    result = read_string "3.24"
+    expect(result).to eq 3.24
+  end
+
+  it "reads negative numbers" do
+    result = read_string "-3.24"
+    expect(result).to be_a Numeric
+    expect(result).to eq -3.24
+  end
+
+  it "reads symbols prefixed with -" do
+    result = read_string "-foo"
+    expect(result).to eq Hammock::Symbol.intern("-foo")
+  end
+
+  it "reads strings" do
+    result = read_string '"Hello"'
+    expect(result).to eq "Hello"
+  end
+
+  it "reads strings with escaped double quotes" do
+    result = read_string '"Hello \"Mate\""'
+    expect(result).to eq 'Hello "Mate"'
+  end
+
+  it "reads strings with escapes" do
+    result = read_string '"Hello \\\\"'
+    expect(result).to eq 'Hello \\'
+  end
+
+  it "reads strings with newlines" do
+    result = read_string '"Hello\nThere"'
+    expect(result).to eq "Hello\nThere"
+  end
+
+  it "reads strings with unicode escape sequences" do
+    result = read_string '"Hello snowman \u2603"'
+    expect(result).to eq "Hello snowman ☃"
+  end
+
+  it "reads character literals" do
+    result = read_string '[\u2603]'
+    expect(result.to_a.first).to eq "☃"
+  end
+
+  it "reads character literal newlines" do
+    result = read_string '[\newline]'
+    expect(result.to_a.first).to eq "\n"
+  end
+
+  it "reads lists with strings and numbers" do
+    result = read_string '(1.2 ("Foo" 3))'
+    expect(result.to_a).to eq [1.2, Hammock::Sequence.from_array(["Foo", 3])]
+  end
+
+  it "reads vectors" do
+    result = read_string '["foo" ["bar"]]'
+    expect(result.to_a).to eq ["foo", Hammock::Vector.from_array(["bar"])]
+  end
+
+  it "reads maps" do
+    result = read_string '{"key" "value"}'
+    expect(result).to eq Hammock::Map.from_array ["key", "value"]
+  end
+
+  it "reads nested maps" do
+    result = read_string '{"key1" {"key2" "value"}}'
+    expect(result).to eq Hammock::Map.from_array(["key1", Hammock::Map.from_array(["key2", "value"])])
+  end
+
+  it "ignores optional commas" do
+    result = read_string '{"key1" "val", "key2", "val"}'
+    expect(result).to eq Hammock::Map.from_array ["key1", "val", "key2", "val"]
+  end
+
+  it "parses basic keywords" do
+    result = read_string ':foo'
+    expect(result).to eq :foo
+  end
+
+  it "parses namespaced keywords" do
+    result = read_string ':foo/bar'
+    expect(result).to eq :"foo/bar"
+  end
+
+  it "parses implicitly namespaced keywords" do
+    result = read_string '::foo'
+    expect(result).to eq :"clojure.core/foo"
+  end
+
+  it "parses complex nested data structures" do
+
+    result = read_string '{:foo [1 2 3]
+                           :bar "Baz"
+                           :quux {:a 1 :b 2}}'
+    expect(result).to eq Hammock::Map.from_array([:foo,
+                                                  Hammock::Vector.from_array([1,2,3]),
+                                                  :bar, "Baz",
+                                                  :quux,
+                                                  Hammock::Map.from_array([:a, 1, :b, 2])])
+  end
+
+  it "parses character literals" do
+    result = read_string '\\a'
+    expect(result).to eq "a"
+  end
+
+  it "parses nil, true, and false" do
+    result = read_string '[true false nil]'
+    expect(result.to_a).to eq [true, false, nil]
+  end
+
+  it "ignores line-ending comments" do
+    result = read_string '["foo" ; ignore me
+                           "bar"] ; me too'
+    expect(result.to_a).to eq ["foo", "bar"]
+  end
+
+  it "reads set literals" do
+    result = read_string '#{1 2 3}'
+    expect(result).to eq Hammock::Set.from_array([1, 2, 3])
+  end
+
+  it "reads regex literals" do
+    str = '#"[\\\\d]+"'
+    result = read_string str
+    expect(result).to eq Regexp.new "[\\d]+"
+  end
+
+  it "reads symbols" do
+    str = '(map foo)'
+    result = read_string str
+    expect(result).to eq Hammock::Sequence.from_array [
+      Hammock::Symbol.intern("map"),
+      Hammock::Symbol.intern("foo")]
+  end
+
+  it "reads symbols with ticks too" do
+    str = "(map' foo)"
+    result = read_string str
+    expect(result).to eq Hammock::Sequence.from_array [
+      Hammock::Symbol.intern("map'"),
+      Hammock::Symbol.intern("foo")]
+  end
+
+  it "reads Ruby constants" do
+    str = 'Object'
+    result = read_string str
+    expect(result).to eq Hammock::Symbol.intern("Object")
+  end
+
+  it "reads quoted symbols" do
+    str = "'foo"
+    result = read_string str
+    expect(result).to eq Hammock::Sequence.from_array [Hammock::Symbol.intern("quote"), Hammock::Symbol.intern("foo")]
+  end
+
+  it "reads quoted lists" do
+    str = "'(foo bar)"
+    result = read_string str
+    expected = Hammock::Sequence.from_array([Hammock::Symbol.intern("quote"), Hammock::Sequence.from_array([Hammock::Symbol.intern("foo"), Hammock::Symbol.intern("bar")])])
+    expect(result).to eq expected
+  end
+
+  it "assigns metadata to the following form" do
+    str = "^{:foo true} [1 2]"
+    result = read_string str
+    expected_meta = Hammock::Map.from_array [:foo, true]
+    expect(result.meta).to eq expected_meta
+  end
+
+  it "assigns keyword metadata" do
+    str = "^:foo [1 2]"
+    result = read_string str
+    expected_meta = Hammock::Map.from_array [:foo, true]
+    expect(result.meta).to eq expected_meta
+  end
+
+  it "assigns keyword metadata" do
+    str = "^:foo ^:bar [1 2]"
+    result = read_string str
+    expected_meta = Hammock::Map.from_array [:foo, true, :bar, true]
+    expect(result.meta).to eq expected_meta
+  end
+
+  it "raises error when attempting to apply meta-data to non-meta-data objects" do
+    str = '^:foo ^:bar "hello"'
+    expect { read_string(str) }.to raise_error
+  end
+
+  it "reads syntax quoted clojure.core things" do
+    form = read_string("(def foo 1)")
+    Hammock::Compiler.evaluate(Hammock::RT.global_env, form)
+    str = '`foo'
+    result = read_string(str)
+    expected = Hammock::Symbol.intern("clojure.core", "foo")
+    expect(result.tail.first).to eq expected
+  end
+
+  it "reads unquotes" do
+    str = '`~blah'
+    result = read_string(str)
+    expected = Hammock::Symbol.intern("blah")
+    expect(result).to eq expected
+  end
+
+  it "reads from a file" do
+    reader = Hammock::Reader.new
+    result = nil
+    File.open(File.expand_path("../../examples/data.hmk", __FILE__)) do |f|
+      result = reader.read(f)
+    end
+    expect(result.to_a).to eq [Hammock::Symbol.intern("map"),
+                               Hammock::Symbol.intern("foo"),
+                               Hammock::Map.from_array([:foo, "bar", :bar, 1, :quux, 1.4])]
+  end
+end