BOBrb 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3afa5f5e8d8cdeb1eab0ffccb533cfc0c79855a4
-  data.tar.gz: 807d159c23278dd86b22bf6e35f4e7048cb72b52
+  metadata.gz: ab7a6ae52bf8772deac68da697c9eca2ea3d941a
+  data.tar.gz: ad5497fc93dcfbdc0acd38c169deddaaf6a7dcc3
 SHA512:
-  metadata.gz: 32ac4ef84bfce1b6aacc7221c065c055ead785644e9dce3334b8b9778f0f66e953331e01c5b9673186ee20d4eea15440322b70a78d4c1634c60868dad56a4dbe
-  data.tar.gz: 5f5925f65fa6965683a1608400e1664b487092f52e2ea9fcd63bcfb1ac9bdddd925ecd162578b4d7e32fd91a2c669a4a9ddd0b55ae99b4b92429b42a2e25e18d
+  metadata.gz: 055881e431d9ec4b37f759e1866d66e5ee47be2678c09e6e4266bef0189de3a660a30beb7e463ff03d31c521b196add0105df96f774a17f33679da3c2efb91a3
+  data.tar.gz: e03703250ccb7930588049964b84b61ba5a49540f72b225752896a66c06041f93451e8b2c8441f37dde2abd0fcb0b3ff3fbf4a7526bdc7125a935135f7849bb9

data/{BOB.gemspec → BOBrb.gemspec}

@@ -1,11 +1,11 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'BOB/version'
+require 'BOBrb/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "BOBrb"
-  spec.version       = BOB::VERSION
+  spec.version       = BOBrb::VERSION
   spec.authors       = ["Stephan Nordnes Eriksen"]
   spec.email         = ["stephanruler@gmail.com"]
 

data/README.md

@@ -6,15 +6,16 @@ BOB is a simple and powerfull ruby pipe system for building complex XML and HTML
 [![Build Status](https://travis-ci.org/stephan-nordnes-eriksen/BOBrb.svg)](https://travis-ci.org/stephan-nordnes-eriksen/BOBrb)
 [![Code Climate](https://codeclimate.com/github/stephan-nordnes-eriksen/BOBrb/badges/gpa.svg)](https://codeclimate.com/github/stephan-nordnes-eriksen/BOBrb)
 [![Test Coverage](https://codeclimate.com/github/stephan-nordnes-eriksen/BOBrb/badges/coverage.svg)](https://codeclimate.com/github/stephan-nordnes-eriksen/BOBrb/coverage)
+[![Gem Version](https://badge.fury.io/rb/BOBrb.svg)](https://badge.fury.io/rb/BOBrb)
 
 ##Install:
 ```ruby
 
-	require "BOB"
+	require "BOBrb"
 ```
 
-###Gem (currently unreleased)
-    gem install BOB
+###Gem
+    gem install BOBrb
 
 ##Usage:
 BOB is a pipe system for generating html structures.
@@ -22,87 +23,87 @@ BOB is a pipe system for generating html structures.
 ###TL;DR
 ```ruby
 
-	BOB.new("div").toString() #=> "<div></div>"
-	BOB.new("div").s() #=> "<div></div>"
-	BOB.new("div").classs("some_class").s() #=> "<div class=\"some_class\"></div>" #NOTICE CLASSS, with three "s"-es. This is because ruby has defined the .class method.
-	BOB.new("div").id("some_id").s() #=> "<div id=\"some_id\"></div>"
-	BOB.new("div.some_class").s() #=> "<div class=\"some_class\"></div>"
-    BOB.new("div#some_id").s() #=> "<div id=\"some_id\"></div>"
-    BOB.new("div").style("min-height: 10px;").s() #=> "<div style=\"min-height: 10px;\"></div>"
-    BOB.new("h1").content("BOB is awesome! <3").s() #=> "<h1>BOB is awesome! <3</h1>"
-    BOB.new("div", {"data-BOB-is-cool": "Yes it is", "data-very-cool": "indeed"}).s() #=> "<div data-BOB-is-cool="Yes it is" data-very-cool="indeed"></div>"
-    BOB.new("div").append("span").s() #=> "<div></div><span></span>"
-    BOB.new("div").prepend("span").s() #=> "<span></span><div></div>"
-	BOB.new("div").insert("span").s() #=> "<div><span></span></div>"
-    BOB.new("div").append("span").id("some_id").s() #=> "<div></div><span id=\"some_id\"></span>"
-    BOB.new("div").append("span").up().id("some_id").s() #=> "<div id=\"some_id\"></div><span></span>"
-    BOB.new("ul").do([1,2,3]).insert("li").content(BOB.data).s() #=> <ul><li>1</li><li>2</li><li>3</li></ul>
-    data = [1,2,3]; BOB.new("ul").do(data).insert("li", {"data-property": BOB.data}).id(BOB.data).s() #=> <ul><li id="1" data-property="1"></li><li id="2" data-property="2"></li><li id="3" data-property="3"></li></ul>
-    BOB.new("ul").do([1,2,3]).insert("li").up().id(BOB.data).s() //INVALID #=> The BOB.data will not be set and you will get the output of: "<ul><li></li><li></li><li></li></ul>".
-    BOB.new("ul").do([1,2,3]).insert("li").content(lambda{return BOB.data() + 2}).s() #=> <ul><li>3</li><li>4</li><li>5</li></ul>
-    data_modifier = lambda{return BOB.data() + 2}; BOB.new("ul").do([1,2,3]).insert("li").content(data_modifier).s() #=> <ul><li>3</li><li>4</li><li>5</li></ul>
+	BOBrb.new("div").toString() #=> "<div></div>"
+	BOBrb.new("div").s() #=> "<div></div>"
+	BOBrb.new("div").classs("some_class").s() #=> "<div class=\"some_class\"></div>" #NOTICE CLASSS, with three "s"-es. This is because ruby has defined the .class method.
+	BOBrb.new("div").id("some_id").s() #=> "<div id=\"some_id\"></div>"
+	BOBrb.new("div.some_class").s() #=> "<div class=\"some_class\"></div>"
+    BOBrb.new("div#some_id").s() #=> "<div id=\"some_id\"></div>"
+    BOBrb.new("div").style("min-height: 10px;").s() #=> "<div style=\"min-height: 10px;\"></div>"
+    BOBrb.new("h1").content("BOB is awesome! <3").s() #=> "<h1>BOB is awesome! <3</h1>"
+    BOBrb.new("div", {"data-BOB-is-cool": "Yes it is", "data-very-cool": "indeed"}).s() #=> "<div data-BOB-is-cool="Yes it is" data-very-cool="indeed"></div>"
+    BOBrb.new("div").append("span").s() #=> "<div></div><span></span>"
+    BOBrb.new("div").prepend("span").s() #=> "<span></span><div></div>"
+	BOBrb.new("div").insert("span").s() #=> "<div><span></span></div>"
+    BOBrb.new("div").append("span").id("some_id").s() #=> "<div></div><span id=\"some_id\"></span>"
+    BOBrb.new("div").append("span").up().id("some_id").s() #=> "<div id=\"some_id\"></div><span></span>"
+    BOBrb.new("ul").do([1,2,3]).insert("li").content(BOBrb.data).s() #=> <ul><li>1</li><li>2</li><li>3</li></ul>
+    data = [1,2,3]; BOBrb.new("ul").do(data).insert("li", {"data-property": BOBrb.data}).id(BOBrb.data).s() #=> <ul><li id="1" data-property="1"></li><li id="2" data-property="2"></li><li id="3" data-property="3"></li></ul>
+    BOBrb.new("ul").do([1,2,3]).insert("li").up().id(BOBrb.data).s() //INVALID #=> The BOBrb.data will not be set and you will get the output of: "<ul><li></li><li></li><li></li></ul>".
+    BOBrb.new("ul").do([1,2,3]).insert("li").content(lambda{return BOBrb.data() + 2}).s() #=> <ul><li>3</li><li>4</li><li>5</li></ul>
+    data_modifier = lambda{return BOBrb.data() + 2}; BOBrb.new("ul").do([1,2,3]).insert("li").content(data_modifier).s() #=> <ul><li>3</li><li>4</li><li>5</li></ul>
     
     //Shorthand syntax:
-    BOB.new("div").i("img", {"src":"some.png"}).u().d([1,2,3]).i("p.number").co(BOB.d).s() #=> "<div><img src="some.png" /><p class="number">1</p><p class="number">2</p><p class="number">3</p></div>"
+    BOBrb.new("div").i("img", {"src":"some.png"}).u().d([1,2,3]).i("p.number").co(BOBrb.d).s() #=> "<div><img src="some.png" /><p class="number">1</p><p class="number">2</p><p class="number">3</p></div>"
 ```
 [Go to shorthand syntax section](#shorthand)
 
 ###Building a simple tag:
 ```ruby
 
-    BOB.new("div").toString() 
+    BOBrb.new("div").toString() 
     #=> "<div></div>"
 ```
 You can also use the shorthand method "s". For a full list see [the shorthand section](#shorthand)
 
 ```ruby
 
-    BOB.new("div").s()
+    BOBrb.new("div").s()
     #=> "<div></div>"
 ```
 
 ###Adding IDs and classes
 ```ruby
 
-	BOB.new("div").classs("some_class").s()
+	BOBrb.new("div").classs("some_class").s()
     #=> "<div class=\"some_class\"></div>"
-    BOB.new("div").id("some_id").s()
-    #=> "<div id=\"some_class\"></div>"
+    BOBrb.new("div").id("some_id").s()
+    #=> "<div id=\"some_id\"></div>"
 ```
 
 This can also be done with the shorthand selector style:
 ```ruby
 
-    BOB.new("div.some_class").s()
+    BOBrb.new("div.some_class").s()
     #=> "<div class=\"some_class\"></div>"
-    BOB.new("div#some_id").s()
-    #=> "<div id=\"some_class\"></div>"
+    BOBrb.new("div#some_id").s()
+    #=> "<div id=\"some_id\"></div>"
 ```
 
 ###Adding styles, content, and custom attributes
 ```ruby
 
-	BOB.new("div").style("min-height: 10px;").s()
+	BOBrb.new("div").style("min-height: 10px;").s()
     #=> "<div style=\"min-height: 10px;\"></div>"
-    BOB.new("h1").content("BOB is awesome! <3").s()
+    BOBrb.new("h1").content("BOB is awesome! <3").s()
     #=> "<h1>BOB is awesome! <3</h1>"
-    BOB.new("div", {"data-BOB-is-cool": "Yes it is", "data-very-cool": "indeed"}).s()
+    BOBrb.new("div", {"data-BOB-is-cool": "Yes it is", "data-very-cool": "indeed"}).s()
     #=> "<div data-BOB-is-cool="Yes it is" data-very-cool="indeed"></div>"
 ```
 
 ###Building and appending/prepending tags:
 ```ruby
 
-    BOB.new("div").append("span").s()
+    BOBrb.new("div").append("span").s()
     #=> "<div></div><span></span>"
-    BOB.new("div").prepend("span").s()
+    BOBrb.new("div").prepend("span").s()
     #=> "<span></span><div></div>"
 ```
 
 ###Building with inserting tags:
 ```ruby
 
-    BOB.new("div").insert("span").s()
+    BOBrb.new("div").insert("span").s()
     #=> "<div><span></span></div>"
 ```
 
@@ -111,7 +112,7 @@ When appending, prepending, or inserting you will effectively branch downwards,
 
 ```ruby
 
-	BOB.new("div").append("span").id("some_id").s()
+	BOBrb.new("div").append("span").id("some_id").s()
 	#=> "<div></div><span id=\"some_id\"></span>"
 ```
 
@@ -119,7 +120,7 @@ In this simlpe example we see that it is the `span` that receives the `id`, not
 
 ```ruby
 
-	BOB.new("div").append("span").up().id("some_id").s()
+	BOBrb.new("div").append("span").up().id("some_id").s()
 	#=> "<div id=\"some_id\"></div><span></span>"	
 ```
 
@@ -140,39 +141,39 @@ To do such branching, without having to re-write all parts manually, you can use
 
 ```ruby
 
-    BOB.new("ul").do([1,2,3]).insert("li").content(BOB.data).s()
+    BOBrb.new("ul").do([1,2,3]).insert("li").content(BOBrb.data).s()
     #=> <ul><li>1</li><li>2</li><li>3</li></ul>
 ```
 
-Here you see `BOB.data` which is a special variable which represend the individal data points when the chain in being executed. It can be used for anything within the scope of the `do`, eg.
+Here you see `BOBrb.data` which is a special variable which represend the individal data points when the chain in being executed. It can be used for anything within the scope of the `do`, eg.
 
 ```ruby
 
 	data = [1,2,3]
-    BOB.new("ul").do(data).insert("li", {"data-property": BOB.data}).id(BOB.data).s()
+    BOBrb.new("ul").do(data).insert("li", {"data-property": BOBrb.data}).id(BOBrb.data).s()
     #=> <ul><li id="1" data-property="1"></li><li id="2" data-property="2"></li><li id="3" data-property="3"></li></ul>
 ```
 
-However, if you use the `up` command and go out of the scope of `do`, `BOB.data` might not work. The behaviour is undefined so errors and/or strange behaviour might occur. Eg:
+However, if you use the `up` command and go out of the scope of `do`, `BOBrb.data` might not work. The behaviour is undefined so errors and/or strange behaviour might occur. Eg:
 
 ```ruby
 
-	BOB.new("ul").do([1,2,3]).insert("li").up().id(BOB.data).s() //INVALID
-    #=> The BOB.data will not be set and you will get the output of: "<ul><li></li><li></li><li></li></ul>".
+	BOBrb.new("ul").do([1,2,3]).insert("li").up().id(BOBrb.data).s() //INVALID
+    #=> The BOBrb.data will not be set and you will get the output of: "<ul><li></li><li></li><li></li></ul>".
 ```
 
-###Processing data and BOB.data
-BOB.data is a function, so **you cannot manipulate `BOB.data` directly.**
+###Processing data and BOBrb.data
+BOBrb.data is a function, so **you cannot manipulate `BOBrb.data` directly.**
 
-It is adviced to do the data manipulation prior to the `do` pipe. However it is possible to manipulate BOB.data inline like this:
+It is adviced to do the data manipulation prior to the `do` pipe. However it is possible to manipulate BOBrb.data inline like this:
 
 ```ruby
 
-	BOB.new("ul").do([1,2,3]).insert("li").content(lambda{return BOB.data() + 2}).s()
+	BOBrb.new("ul").do([1,2,3]).insert("li").content(lambda{return BOBrb.data() + 2}).s()
     #=> <ul><li>3</li><li>4</li><li>5</li></ul>
     //Or you can predefine a set of manipulations
-    data_modifier = lambda{return BOB.data() + 2}
-    BOB.new("ul").do([1,2,3]).insert("li").content(data_modifier).s()
+    data_modifier = lambda{return BOBrb.data() + 2}
+    BOBrb.new("ul").do([1,2,3]).insert("li").content(data_modifier).s()
     #=> <ul><li>3</li><li>4</li><li>5</li></ul>
 ```
 
@@ -183,24 +184,24 @@ Writing out these pipes can be tiresom if you are building big and complex struc
 
 Long Version | Short Version
 ------------ | -------------
-.insert   | .i
-.append   | .a
-.prepend  | .p
-.content  | .co
-.style    | .st
-.classs   | .cl
-.id       | .id
-.style    | .st
-.toString | .s
-.do       | .d
-.up       | .u
-BOB.data  | BOB.d
+.insert      | .i
+.append      | .a
+.prepend     | .p
+.content     | .co
+.style       | .st
+.classs      | .cl
+.id          | .id
+.style       | .st
+.toString    | .s
+.do          | .d
+.up          | .u
+BOBrb.data   | BOBrb.d
 
 Now you can get tight and cozy syntax like this:
 
 ```ruby
 
-	BOB.new("div").i("img", {"src":"some.png"}).u().d([1,2,3]).i("p.number").co(BOB.d).s()
+	BOBrb.new("div").i("img", {"src":"some.png"}).u().d([1,2,3]).i("p.number").co(BOBrb.d).s()
 	#=> "<div><img src="some.png"></img><p class="number">1</p><p class="number">2</p><p class="number">3</p></div>"
 ```
 
@@ -210,16 +211,16 @@ Better examples coming
 ```ruby
 	
 	data = ["Team member1", "team member2", "team member3"]
-	BOB.new("ul").do(data).insert("li.team").content(BOB.data).s()
+	BOBrb.new("ul").do(data).insert("li.team").content(BOBrb.data).s()
 	#=> "<ul><li class="team">Team member1</li><li class="team">team member2</li><li class="team">team member3</li></ul>"
 
-	BOB.new("div#wrapper").insert("div#searchbar").up().insert("footer").do(["team","contact","buy"]).insert("h2").content(BOB.data).s()
+	BOBrb.new("div#wrapper").insert("div#searchbar").up().insert("footer").do(["team","contact","buy"]).insert("h2").content(BOBrb.data).s()
 	#=> "<div id="wrapper"><div id="searchbar"></div><footer><h2>team</h2><h2>contact</h2><h2>buy</h2></footer></div>"
 
-	BOB.new("div#wrapper").insert("div#searchbar").up().insert("footer").do(["team","contact","buy"]).insert("h2",{"onclick": lambda{return ("alert('" + BOB.data() + "');") }}).content(BOB.data).s()
+	BOBrb.new("div#wrapper").insert("div#searchbar").up().insert("footer").do(["team","contact","buy"]).insert("h2",{"onclick": lambda{return ("alert('" + BOBrb.data() + "');") }}).content(BOBrb.data).s()
 	#=> "<div id="wrapper"><div id="searchbar"></div><footer><h2 onclick="alert('team');">team</h2><h2 onclick="alert('contact');">contact</h2><h2 onclick="alert('buy');">buy</h2></footer></div>"
 
-	BOB.new("div#wrapper").insert("div#searchbar").up().insert("footer").do(["team","contact","buy"]).insert("h2",{"onclick": lambda{return ("alert('" + BOB.data() + "');") }}).content(BOB.data).up().up().prepend("a",{"href": "http://www.google.com"}).content("google").s()
+	BOBrb.new("div#wrapper").insert("div#searchbar").up().insert("footer").do(["team","contact","buy"]).insert("h2",{"onclick": lambda{return ("alert('" + BOBrb.data() + "');") }}).content(BOBrb.data).up().up().prepend("a",{"href": "http://www.google.com"}).content("google").s()
 	#=> "<a href="http://www.google.com">google</a><div id="wrapper"><div id="searchbar"></div><footer><h2 onclick="alert('team');">team</h2><h2 onclick="alert('contact');">contact</h2><h2 onclick="alert('buy');">buy</h2></footer></div>"
 ```
 
@@ -227,7 +228,7 @@ Better examples coming
 Please help contribute to this project. It is brand new, and there are probably loads of features that can be added. 
 
 ###Planned features
- - Adding nested data-aquisition data, eg: BOB.new("div").do(["a", "b"]).do([1,2]).in("a").classs(BOB.data[0]).co(BOB.data[1])
+ - Adding nested data-aquisition data, eg: BOBrb.new("div").do(["a", "b"]).do([1,2]).in("a").classs(BOBrb.data[0]).co(BOBrb.data[1])
  #=> <div><a class="a">1</a><a class="a">2</a><a class="b">1</a><a class="b">2</a></div>
 
 ##License

data/lib/BOBrb.rb

@@ -0,0 +1,17 @@
+require "BOBrb/version"
+require "BOBrb/element"
+require "BOBrb/child_array"
+
+module BOBrb
+	# Your code goes here...
+	def self.new(*args)
+		BOBrb::Element.new(*args)
+	end
+
+	def self.data(*args)
+		BOBrb::Element.method(:data)
+	end
+	def self.d(*args)
+		BOBrb::Element.method(:d)
+	end
+end

data/lib/{BOB → BOBrb}/child_array.rb

@@ -1,4 +1,4 @@
-module BOB
+module BOBrb
 	class ChildArray
 		def initialize (dataset, parent)
 			@dataset = dataset
@@ -6,13 +6,13 @@ module BOB
 			@bobs = []
 		end
 
-		#No point in doing this on parent. Does not make sense to do ".do(data).id(BOB::Element.data)"
+		#No point in doing this on parent. Does not make sense to do ".do(data).id(BOBrb::Element.data)"
 		def content (content)
 			self.co(content)
 		end
 		def co (content)
 			@dataset.each_with_index do |item, i|
-				BOB::Element.data = item
+				BOBrb::Element.data = item
 				@bobs[i].co(content) if @bobs[i]
 			end
 			return self
@@ -22,7 +22,7 @@ module BOB
 		end
 		def st (style)
 			@dataset.each_with_index do |item, i|
-				BOB::Element.data = item
+				BOBrb::Element.data = item
 				@bobs[i].st(style) if @bobs[i]
 			end
 			return self
@@ -32,14 +32,14 @@ module BOB
 		end
 		def cl (object_class)
 			@dataset.each_with_index do |item, i|
-				BOB::Element.data = item
+				BOBrb::Element.data = item
 				@bobs[i].cl(object_class) if @bobs[i]
 			end
 			return self
 		end
 		def id (object_id)
 			@dataset.each_with_index do |item, i|
-				BOB::Element.data = item
+				BOBrb::Element.data = item
 				@bobs[i].id(object_id) if @bobs[i]
 			end
 			return self
@@ -49,7 +49,7 @@ module BOB
 		end
 		def i (data, options=nil)
 			@dataset.each_with_index do |item, i|
-				BOB::Element.data = item
+				BOBrb::Element.data = item
 				if @bobs[i]
 					@bobs[i] = @bobs[i].insert(data, options)
 				else
@@ -64,7 +64,7 @@ module BOB
 		end
 		def a (data, options=nil)
 			@dataset.each_with_index do |item, i|
-				BOB::Element.data = item
+				BOBrb::Element.data = item
 				if @bobs[i]
 					@bobs[i] = @bobs[i].a(data, options)
 				else
@@ -79,7 +79,7 @@ module BOB
 		end
 		def p (data, options=nil)
 			@dataset.each_with_index do |item, i|
-				BOB::Element.data = item
+				BOBrb::Element.data = item
 				if @bobs[i]
 					@bobs[i] = @bobs[i].p(data, options)
 				else
@@ -117,7 +117,7 @@ module BOB
 		end
 		def d (data)
 			for bob in @bobs
-				BOB::Element.data = item
+				BOBrb::Element.data = item
 				if @bobs[i]
 					@bobs[i] = @bobs[i].d(data)
 				else
@@ -132,14 +132,14 @@ module BOB
 		end
 		def u
 			unless @bobs[0]
-				BOB::Element.data = nil
+				BOBrb::Element.data = nil
 				return @parent
 			end
 			[0...@bobs.length].each do |i|
 				@bobs[i] = @bobs[i].u()
 			end
 			if @bobs[0] == @parent
-				BOB::Element.data = nil
+				BOBrb::Element.data = nil
 				return @parent
 			else
 				return self

data/lib/{BOB → BOBrb}/element.rb

@@ -1,7 +1,7 @@
 # BOB
 
 # build or bail
-module BOB
+module BOBrb
 	class Element
 		attr_accessor :object_content, :parent
 		@@data = nil

data/lib/BOBrb/version.rb

@@ -0,0 +1,3 @@
+module BOBrb
+  VERSION = "0.1.2"
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: BOBrb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Stephan Nordnes Eriksen
@@ -77,8 +77,8 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
-- BOB.gemspec
 - BOB.png
+- BOBrb.gemspec
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
@@ -87,10 +87,10 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
-- lib/BOB.rb
-- lib/BOB/child_array.rb
-- lib/BOB/element.rb
-- lib/BOB/version.rb
+- lib/BOBrb.rb
+- lib/BOBrb/child_array.rb
+- lib/BOBrb/element.rb
+- lib/BOBrb/version.rb
 homepage: https://github.com/stephan-nordnes-eriksen/BOBrb
 licenses:
 - MIT

data/lib/BOB.rb

@@ -1,17 +0,0 @@
-require "BOB/version"
-require "BOB/element"
-require "BOB/child_array"
-
-module BOB
-	# Your code goes here...
-	def self.new(*args)
-		BOB::Element.new(*args)
-	end
-
-	def self.data(*args)
-		BOB::Element.method(:data)
-	end
-	def self.d(*args)
-		BOB::Element.method(:d)
-	end
-end

data/lib/BOB/version.rb

@@ -1,3 +0,0 @@
-module BOB
-  VERSION = "0.1.0"
-end