colby 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+*.gem

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/README.md

@@ -0,0 +1,28 @@
+# Colby
+
+Experimenting with bringing Clojure's goodness in Ruby.
+
+- This project depends on [Hamster](https://github.com/harukizaemon/hamster)
+- The basic idea for now is to have something broadly equivalent to [Mori](http://swannodette.github.com/mori/), but in Ruby
+
+## Testing
+
+- `rspec .`
+
+## Usage
+
+- make sure you have 1.9.3-p194
+- `bundle install`
+
+```ruby
+require './colby.rb'
+
+include Colby::Core
+
+# Now you can build hash_map, vec, list, or set
+
+# Also, you have clojure-like functions such as assoc, get, conj, has_key
+
+# check the spec to see examples
+
+```

data/colby.gemspec

@@ -0,0 +1,23 @@
+$: << "#{File.dirname(__FILE__)}/lib"
+require 'colby'
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Gursimran Singh"]
+  gem.email         = ["g@kilotau.com"]
+  gem.description   = %q{Small wrapper and functions for persistent, immutable data structures.}
+  gem.summary       = %q{Colby makes it easier to work with persistent, immutable data structures.
+                         It wraps Hamster's excellent data structures and provides functions to work
+                         with them that are similar to Clojure, but not exactly.}
+  gem.homepage      = "http://github.com/gnarmis/colby"
+
+  gem.add_development_dependency('rake')
+  gem.add_development_dependency('rspec')
+
+  gem.add_dependency('hamster')
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map {|f| File.basename(f)}
+  gem.name          = "colby"
+  gem.require_paths = ["lib"] 
+  gem.version       = Colby::VERSION
+end

data/lib/colby.rb

@@ -0,0 +1,3 @@
+require 'colby/core'
+require 'colby/version'
+

data/lib/colby/core.rb

@@ -0,0 +1,114 @@
+require 'hamster'
+
+class IndexOutOfBounds < Exception; end
+
+module Colby
+  module Core
+
+    def hash_map(*pairs)
+      return Hamster.hash(Hash[*pairs]) if pairs.is_a? Array
+      return Hamster.hash(*pairs) if pairs.is_a? Hash
+    end
+
+    def vec(*data)
+      Hamster.vector(*data)
+    end
+
+    def list(*data)
+      Hamster.list(*data)
+    end
+
+    def set(*data)
+      Hamster.set(*data)
+    end
+
+    def conj(coll, item)
+      return coll.cons(item) if coll.is_a? Hamster::List
+      return coll.add(item) if coll.is_a? Hamster::Vector
+      return coll.merge(item) if coll.is_a? Hamster::Hash
+      return Hamster.set(*coll, item) if coll.is_a? Hamster::Set
+    end
+
+    def assoc(coll, *pairs)
+      @retval = coll
+      pairs.each_slice(2) do |k,v|
+        @retval = assoc_2(@retval, k , v)
+      end
+      @retval
+    end
+
+    def assoc_2(coll, key, val)
+      if coll.is_a? Hamster::Hash
+        return coll.send(:put, key) {val}
+      end
+      if coll.is_a? Hamster::Vector
+        if has_key(coll, key)
+          return coll.send(:set, key, val)
+        else
+          raise IndexOutOfBounds
+        end
+      end
+    end
+
+    def get(coll, key)
+      coll.get(key) unless coll.is_a? Hamster::List
+    end
+
+    def nth(coll, key)
+      return get(coll, key) if coll.is_a? Hamster::Vector
+      return coll.to_a[key] if coll.is_a? Hamster::List
+    end
+
+    def find(coll, key)
+      return Core.vec(key, Core.get(coll, key)) if coll.is_a? Hamster::Vector
+      return Core.vec(key, Core.get(coll,key)) if coll.is_a? Hamster::Hash
+    end
+
+    def has_key(coll, key)
+      return coll.has_key?(key) if coll.is_a? Hamster::Hash
+      return coll[key] != nil if (coll.is_a? Hamster::Vector) || (coll.is_a? Hamster::Set)
+      nil
+    end
+
+    def count(coll)
+      return coll.length
+    end
+
+    def peek(coll)
+      return coll.head if coll.is_a? Hamster::List
+      return coll.last if coll.is_a? Hamster::Vector
+    end
+
+    def pop(coll)
+      return coll.tail if coll.is_a? Hamster::List
+      if coll.is_a? Hamster::Vector
+        return vec(*coll.to_a[0..-2])
+      end
+    end
+
+    def zip_map(coll1, coll2)
+      return hash_map(Hash[coll1.to_a.zip(coll2.to_a)])
+    end
+
+    def seq(data)
+      if data.is_a? Hamster::List
+        return data
+      elsif data.is_a? Array or data.is_a? Hamster::Vector
+        return list(*data)
+      elsif data.is_a? Hash
+        return list(*data.keys.to_a.zip(data.values.to_a))
+      elsif data.is_a? Hamster::Hash
+        l = list
+        data.foreach {|k,v| l = conj(l,(list k, v))}
+        return l
+      elsif data.is_a? Hamster::Set
+        return (list(*data)).sort
+      elsif data.is_a? String
+        return list(*data.split(""))
+      else
+        raise Exception
+      end
+    end
+
+  end
+end

data/lib/colby/version.rb

@@ -0,0 +1,3 @@
+module Colby
+  VERSION = "0.0.1"
+end

data/spec/core_spec.rb

@@ -0,0 +1,148 @@
+$: << "#{File.dirname(__FILE__)}/../lib"
+
+require 'colby'
+
+include Colby::Core
+
+describe "Colby" do
+
+  describe "Core" do
+
+    it "should construct hash-maps given a Ruby Hash" do
+      hash_map(:a => 1).should == Hamster.hash(:a => 1)
+    end
+    it "should construct vectors given values" do
+      vec(1,2,3).should == Hamster.vector(1,2,3)
+    end
+    it "should construct lists given values" do
+      list(1,2,3).should == Hamster.list(1,2,3)
+    end
+    it "should construct sets given values" do
+      set(1,2,3,3).should == Hamster.set(1,2,3,3)
+    end
+
+    it "should conj items to head of list" do
+      conj(list(1,2,3), 0).should == list(0,1,2,3)
+    end
+    it "should conj items to end of vector" do
+      conj(vec(1,2,3), 0).should == vec(1,2,3,0)
+    end
+    it "should conj hash_maps by merging them" do
+      conj(hash_map(:a=>1), 
+        hash_map(:b=>2,:c=>3)).should == hash_map(:a=>1,:b=>2,:c=>3) 
+    end
+    it "should assoc new key-value pairs when conj'ing hash_maps" do
+      conj(hash_map(:a=>1), 
+        hash_map(:a=>2,:c=>3)).should == hash_map(:a=>2,:c=>3) 
+    end
+    it "should conj sets by making a bigger set" do
+      conj(set(1,2,3,3), 4).should == set(1,2,3,4)
+    end
+
+
+    it "should assoc any number of pairs into a hash_map collection" do
+      assoc(hash_map(:a=>1), 
+                :a, 2, 
+                :b, 3, 
+                :c, 4).should == hash_map(:a=>2,
+                                             :b=>3,
+                                             :c=>4)
+    end
+    it "should assoc index-bounded pairs into a vector collection" do
+      assoc(vec(1,2,3),0,4,1,5,2,6).should == vec(4,5,6)
+    end
+    it "should raise an exception if unbounded pairs used to assoc into a vec" do
+      expect {assoc(vec(1,2),9,9)}.to raise_error
+    end
+
+
+    it "should return value when using get with a hash_map" do
+      get( hash_map(:a=>1), :a).should == 1
+    end
+    it "should return value when using get with a vector" do
+      get( vec(1,2), 0).should == 1
+    end
+
+
+    it "should return value when using nth with a vec" do
+      nth(vec(1,2,3), 0).should == 1
+    end
+    it "should return value when using nth with a list" do
+      nth(list(1,2,3), 0).should == 1
+    end
+    it "should not return value when using nth with a set" do
+      nth(set(1,2,3), 0).should_not == 1
+    end
+    it "should not return value when using nth with a hash_map" do
+      nth(hash_map(1,2,3,4), 1).should_not == 2
+    end
+
+
+
+    it "should return key/val pair as a vector for a vector" do
+      find(vec(1,2),0).should == vec(0,1)
+    end
+    it "should return key/val pair as a vector for a hash_map" do
+      find(hash_map(1,2,3,4), 3).should == vec(3,4)
+    end
+
+
+    it "should return bool if vec has or doesn't have key" do
+      has_key(vec(1,2), 0).should == true
+      has_key(vec(1,2), 3).should == false
+    end
+    it "should return bool if hash_map has or doesn't have key" do
+      has_key(hash_map(:a=>1), :a).should == true
+      has_key(hash_map(:a=>1), 3).should == false
+    end
+
+
+    it "should return count for lists" do
+      count(list(1,2,3)).should == 3
+    end
+    it "should return count for vectors" do
+      count(vec(1,2,3)).should == 3
+    end
+    it "should return count for sets" do
+      count(set(1,2,3)).should == 3
+    end
+    it "should return count for hash_maps" do
+      count(hash_map(1=>2,3=>4)).should == 2
+    end
+
+
+    it "should return head of list when using peek" do
+      peek(list(1,2,3)).should == 1
+    end
+    it "should return last element of vec when using peek" do
+      peek(vec(1,2,3)).should == 3
+    end
+
+
+    it "should return list with head removed when using pop" do
+      pop(list(1,2,3)).should == list(2,3)
+    end
+    it "should return vec with last item removed when using pop" do
+      pop(vec(1,2,3)).should == vec(1,2)
+    end
+
+
+    it "should zip two seqs into a hash_map" do
+      zip_map(vec(1,2,3), list(4,5,6)).should == hash_map(1,4,2,5,3,6)
+    end
+
+
+    it "should convert Arrays, lists, and vecs into a seq (list)" do
+      seq([1,2,4,3]).should == list(1,2,4,3)
+      seq(list(1,2,4,3)).should == list(1,2,4,3)
+      seq(vec(1,2,4,3)).should == list(1,2,4,3)
+    end
+    it "should convert a Hash into a seq" do
+      seq(hash_map(:a,2)).should == list(list(:a,2))
+    end
+    it "should convert a String into a seq" do
+      seq("abc").should == list("a","b","c")
+    end
+  end
+
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: colby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Gursimran Singh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hamster
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Small wrapper and functions for persistent, immutable data structures.
+email:
+- g@kilotau.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- colby.gemspec
+- lib/colby.rb
+- lib/colby/core.rb
+- lib/colby/version.rb
+- spec/core_spec.rb
+homepage: http://github.com/gnarmis/colby
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Colby makes it easier to work with persistent, immutable data structures.
+  It wraps Hamster's excellent data structures and provides functions to work with
+  them that are similar to Clojure, but not exactly.
+test_files: []