o 1.0.2 → 2.0.0

data/lib/o/hash_method_fix.rb

@@ -0,0 +1,13 @@
+class O
+	module HashMethodFix
+	def _merge! obj
+		_child.merge! O.get(obj)
+		self
+	end
+
+	def _merge obj
+		data = _child.merge(O.get(obj))
+		O[data]
+	end
+	end
+end

data/lib/o/parser.rb

@@ -0,0 +1,88 @@
+class O
+	class Parser
+		attr_reader :content
+
+		class << self
+			def compile content
+				parser = Parser.new content
+				parser.compile
+			end
+		end
+
+		def initialize content
+			@content = content
+		end
+
+		def compile
+			script = ""
+			indent_counts = 0
+			block_start = false
+
+			scan do |token, statement|
+				case token
+				when :block_start
+					block_start = true
+					statement = statement.sub(":", " do")
+					script << statement << "\n"
+				when :statement
+					script << statement << "\n"
+				when :indent
+					indent_counts += 1
+					script << "\t"*indent_counts
+				when :undent
+					script << "\t"*indent_counts
+				when :dedent
+					if block_start
+						block_start = false
+						script << "\t"*(indent_counts-1) + "end\n"
+					else
+						script << "\t"*(indent_counts-1)
+					end
+					indent_counts -= 1
+				end
+			end
+			script
+		end
+		
+	private
+	
+		def scan
+			last_indent = 0
+
+			content.scan(/(.*?)(\n+|\Z)/).each do |line, newline|
+
+				#pd line.match(/^(\t*)(.*)/)
+				_, indents, statement = line.match(/^(\t*)(.*)/).to_a
+
+				# indent
+				# a:
+				#   b 1
+				#   c:
+				#     d 1
+				#     e:
+				#       f 1
+				#   g 1
+				indent = indents.count("\t")
+				counts = indent - last_indent
+				last_indent = indent
+
+				if counts == 0
+					yield :undent
+				else
+					counts.abs.times {
+						yield (counts>0 ? :indent : :dedent)
+					}
+				end
+
+				# statement
+				if statement =~ /:\s*$/
+					yield :block_start, statement.gsub(/\s*:\s*$/, ':')
+				else
+					yield :statement, statement
+				end
+			end
+
+
+		end
+	end
+end

data/lib/o/semantics.rb

@@ -0,0 +1,12 @@
+class O
+	module Semantics
+	# semantic
+	def no
+		false
+	end
+
+	def yes
+		true
+	end
+	end
+end

data/{version.rb → lib/o/version.rb}

@@ -1,8 +1,8 @@
-module O
+class O
 	module VERSION
-		MAJOR = 1
+		MAJOR = 2
 		MINOR = 0
-		PATCH = 2
+		PATCH = 0
 
 		IS = [MAJOR, MINOR, PATCH].join(".") 
 	end

data/lib/o1.rb

@@ -0,0 +1,189 @@
+#
+# internal: store data in a Hash, the key of the Hash is always converted to symbol.
+#
+#
+#
+class O < Hash
+	autoload :VERSION,	"o/version"
+
+	# PATH for O.load
+	PATH = []
+	Error = Exception.new 
+	LoadError = Exception.new(Error)
+
+	class O_Eval
+		def _data
+			_data = {}
+			self.instance_variables.each do |k|
+				key = k[1..-1].to_sym
+				value = self.instance_variable_get(k)
+				_data[key] = value 
+			end
+			_data
+		end
+	end
+
+	class << self
+		# convert <#Hash> to <#O>
+		#
+		# @param [hash] hash
+		# @return O
+		def from_hash hash
+			o = O.new
+			o._replace hash
+		end
+
+		# load a configuration file,
+		# support PATH, and '~/.gutenrc'
+		#
+		# first try name.rb, then use name
+		#
+		# @example
+		#   option = O.load("~/.gutenrc")
+		#
+		#   option = O.load("/absolute/path/a.rb")
+		#   
+		#   O::Path << "/home"
+		#   option = O.load("guten")  #=> try guten.rb; then try guten
+		#   option = O.load("guten.rb")
+		#
+		# @param [String] name
+		# @return [O]
+		def load name
+			path = nil
+			if name =~ /^~/
+				file = File.expand_path(name)
+				path = file if File.exists?(file)
+			elsif File.absolute_path(name) == name
+				path = name if File.exists?(name)
+			else
+				catch :break do
+					PATH.each  do |p|
+						['.rb', ''].each {|ext|
+							file = File.join(p, name+ext)
+							if File.exists? file
+								path = file
+								throw :break
+							end
+						}
+					end
+				end
+			end
+
+			raise LoadError, "can't find file -- #{name}" unless path
+
+			eval_file path
+		end
+
+		# relative load a configuration file
+		# @see load
+		#
+		# @param [String] name
+		# @return [O] option
+		def relative_load name
+			pd caller if $TEST
+			a,file, line, method = caller[0].match(/^(.*):(\d+):.*`(.*)'$/).to_a
+			raise LoadError, "#{type} is called in #{file}" if file=~/\(.*\)/ # eval, etc.
+
+			file = File.readlink(file) if File.symlink?(file)
+
+			path = nil
+			[".rb", ""].each do |ext|
+				f = File.absolute_path(File.join(File.dirname(file), name+ext))
+				if File.exists?(f)
+					path = f
+					break
+				end
+			end
+
+			raise LoadError, "can't find file -- #{name}" unless path
+
+			eval_file path
+		end
+
+		private
+		def eval_file path
+			content = File.open(path){|f| f.read}
+			o_eval = O_Eval.new
+			o_eval.instance_eval(content)
+			O.from_hash(o_eval._data)
+		end
+
+	end
+
+	attr_reader :_data
+
+	def initialize default=nil, &blk
+		@_data = Hash.new(default)
+		if blk
+			o_eval = O_Eval.new
+			o_eval.instance_eval &blk
+			@_data.merge!(o_eval._data)
+		end
+	end
+
+	def []= key, value
+		@_data[key.to_sym] = value
+	end
+
+	def [] key
+		@_data[key.to_sym]
+	end
+
+	def + other
+		O.new(@_data, other._data)
+	end
+
+	def _replace data
+		case data
+		when Hash
+			@_data = data
+		when O
+			@_data = data._data
+		end
+		self
+	end
+
+	#
+	# _method goes to @_data.send(_method, ..)
+	# method? #=> !! @_data[:method]
+	# method #=> @_data[:method]
+	# method=value #=> @_data[:method]=value
+	#
+	def method_missing method, *args, &blk
+		if method =~ /(.*)=$/
+			@_data[$1.to_sym] = args[0]
+		elsif method =~ /(.*)\?$/
+			!! @_data[$1.to_sym]
+		elsif method =~ /^_(.*)/
+			method = $1.to_sym
+			args.map!{|arg| O===arg ? arg._data : arg} 
+			rst = @_data.send(method, *args, &blk)
+
+			if [:merge!].include method
+				self
+			elsif [:merge].include method
+				O.new(rst)
+			end
+		else
+			@_data[method]
+		end
+	end
+
+	def inspect 
+		rst = "<#O "
+		@_data.each do |k,v|
+			rst << "#{k}:#{v.inspect} "
+		end
+		rst << " >" 
+	end
+
+	alias to_s inspect
+
+end
+
+module Kernel
+	def O default=nil, &blk
+		O.new(default, &blk)
+	end
+end

data/o.gemspec

@@ -1,5 +1,5 @@
-$: << "."
-require "version"
+$: << "lib"
+require "o/version"
 
 Gem::Specification.new do |s|
 	s.name = "o"

data/spec/o/parser_spec.rb

@@ -0,0 +1,120 @@
+require "spec_helper"
+
+class O::Parser
+	public :compile, :scan
+end
+
+describe O::Parser do
+	describe "#token" do
+		it "tests" do
+			content = <<EOF
+a 1
+b:
+	c {d: 1}
+	d 1
+	e:
+		f 1
+EOF
+			content = <<EOF
+a 1
+b:
+	c {d: 1}
+	d 1
+	e:
+		f 1
+g 1
+EOF
+
+			parser = O::Parser.new content
+			parser.scan do |token, statement|
+				#pd token, statement
+			end
+		end
+	end
+
+	describe "#compile" do
+		it "tests" do
+			content = <<EOF
+a:
+	b 1
+EOF
+
+			content1 = <<EOF
+a 1
+b:
+	c {d: 1}
+	d 1
+	e:
+		f 1
+g 1
+EOF
+		parser = O::Parser.new content
+		parser.scan do |token, statement|
+			#pd token, statement
+		end
+
+		parser = O::Parser.new content
+		#puts parser.compile
+		end
+
+
+		it "has no effects to normal ruby code" do
+			content = <<EOF
+a 1
+b do
+	c {d: 1}
+	d 1
+	e do
+		f 1
+	end
+end
+EOF
+			parser = O::Parser.new content
+			parser.scan do |token, statement|
+				#pd token, statement
+			end
+
+			parser = O::Parser.new content
+			#puts parser.compile
+		end
+
+		it "has both yaml-style and ruby-style" do
+			content = <<EOF
+a 1
+b: 
+	c {d: 1}
+	d 1
+	e do
+		f 1
+	end
+EOF
+			parser = O::Parser.new content
+			parser.scan do |token, statement|
+				#pd token, statement
+			end
+
+			parser = O::Parser.new content
+			#puts parser.compile
+		end
+
+	end
+
+	describe ".compile" do
+		it "works" do
+			content = <<EOF
+a:
+	b 1
+EOF
+			right = <<EOF
+a do
+	b 1
+end\n
+EOF
+
+			O::Parser.compile(content).should == right
+
+		end
+	end
+
+
+end