khrl 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 84ee2b18b834c7130cb718543e5c996b54881904
+  data.tar.gz: 317741454576c9dc155af71f8135fad014c04bf7
+SHA512:
+  metadata.gz: 7bb17aa382e2e958a980d51d1d502b76b4a9126c7ccf0653cd5099c621b6517fe051838a413a3d1ccdc2bed935ad8db0123196010a4ecef774f000c2e876c334
+  data.tar.gz: 42f75450dcf26de2c9d28a9f31f2298f7f046955e497dcd88b7e691b213ce1dafccb84b80ddc0cc5d443cea3293729c0049390aa8df713b47dd2bb7e03d8547d

data/khrl.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name        = 'khrl'
+  s.version     = '0.0.1'
+  s.date        = '2014-10-14'
+  s.summary     = "KHRL"
+  s.description = "private ruby lib"
+  s.authors     = ["Koihik"]
+  s.email       = 'koihik@hotmail.com'
+  s.files       = Dir['**/*']
+  s.homepage    = 'https://rubygems.org/gems/khrl'
+  s.license     = 'MIT'
+end

data/lib/file/kfile.rb

@@ -0,0 +1,56 @@
+module KFile
+    require "fileutils"
+
+    def self.delete(dir)
+        FileUtils.remove_dir(dir) if File.exists? dir
+    end
+
+    def self.clear(dir)
+        return if !File.exists? src
+        Dir.foreach(dir) do |path|
+            if path !="." and path !=".."
+                delete(dir+"/"+path)
+            end
+        end
+    end
+
+    def self.copy(src,dest)
+        return if !File.exists? src
+        if File.directory? src
+            Dir.mkdir(dest) if !File.exist? dest
+            Dir.foreach(src) do |path|
+                if path !="." and path !=".."
+                    copy(src+"/"+path,dest+"/"+path)
+                end
+            end
+        else
+            FileUtils.cp(src,dest)
+        end
+    end
+
+    def self.list(dir,recursive = true,&proc)
+        return if !File.exists? dir
+        if File.directory?(dir)
+            Dir.foreach(dir) do |path|
+                if path !="." && path !=".."
+                    full_path = dir + "/" + path
+                    if recursive
+                        list(full_path,recursive,&proc)
+                    else
+                        yield full_path if !File.directory?(full_path)
+                    end
+                end
+            end
+        else
+        yield dir
+        end
+    end
+    
+    def self.read(file_path,encoding = 'utf-8')
+    	File.open(file_path,"r:#{encoding}"){|f|
+    		return f.read
+    	}
+    end
+
+end
+

data/lib/khrl.rb

@@ -0,0 +1,2 @@
+require 'file/kfile'
+require 'xml/kxml'

data/lib/xml/kxml.rb

@@ -0,0 +1,276 @@
+module KXML
+    class Document
+		attr_accessor :encoding
+		attr_accessor :version
+		attr_accessor :root
+		
+		def initialize(data)
+			case data
+				when KXML::Node
+					@root = data
+	            when String
+		            if data =~ /^[<>\/]/
+		                parse_from_string(data)
+		            else
+		                @root = Node.new(data)
+		            end
+	            when File
+	            	parse_from_file(data)
+	            else
+	            	raise "Unsupport Param Type : #{data.class}"
+            end
+            yield @root if block_given?
+		end
+		
+		def to_s(format = Format::MINIMUM)
+			return @root.to_s(format)
+		end
+		
+		private 
+		
+		def parse_from_string(data)
+        	pre_parse()
+        	push_data(data)
+        	post_parse()
+        end
+        
+        def parse_from_file(file)
+        	pre_parse()
+        	line = file.gets
+        	while(line != nil)
+        		push_data(line)
+        		line = file.gets
+        	end
+        	post_parse()
+        end
+		
+		def pre_parse
+            require File.expand_path('../xml_parser.rb',__FILE__)
+        	@__parser = SAXParser.new
+        	@__tag_stack = []
+        	@__parser.handler=->(param){
+	            case param[:type]
+	            when SAXParser::DOCUMENT_STATEMENT
+	            	@encoding = param[:attributes]['encoding']
+	            	@version = param[:attributes]['version']
+	            when SAXParser::START_TAG
+            		node = Node.new(param[:name])
+            		node.attributes.merge!(param[:attributes]) if param[:attributes] != nil
+	            	if @root == nil
+	            		@root = node
+	            	else
+	            		@__tag_stack.last << node
+	            	end
+            		@__tag_stack << node
+	            when SAXParser::END_TAG
+            		raise "Tag mismatch : <#{@__tag_stack.last.name}> - </#{param[:name]}>" if @__tag_stack.last ==nil || @__tag_stack.last.name != param[:name]
+            		@__tag_stack.pop
+	            when SAXParser::SELF_CLOSE_TAG
+            		node = Node.new(param[:name])
+            		node.attributes.merge!(param[:attributes]) if param[:attributes] != nil
+            		if @root == nil
+	            		@root = node
+	            	else
+	            		@__tag_stack.last << node
+	            	end
+	            when SAXParser::COMMENTS
+	            	#ignore
+	            when SAXParser::CONTENT
+	            	next if @__tag_stack.last == nil
+	            	@__tag_stack.last.content = '' if @__tag_stack.last.content == nil
+	            	@__tag_stack.last.content += param[:name].gsub(/\s/,"")
+	            end
+            }
+        end
+        
+        def push_data(data)
+        	@__parser << data
+        end
+        
+        def post_parse
+        	@__parser.end
+        	
+        	@__parser = nil
+        	@__tag_stack = nil
+        end
+    end
+
+    class Node
+        # @_children
+        # @_content
+        # @_name
+        # @_attributes
+        def initialize(data)
+            @_children = []
+            @_attributes = {}
+            case data
+	            when String
+		            if data =~ /^[<>\/]/
+		                parse_from_string(data)
+		            else
+		                @_name = data
+		            end
+	            when File
+	            	parse_from_file(data)
+	            else
+	            	raise "Unsupport Param Type : #{data.class}"
+            end
+            yield self if block_given?
+        end
+
+        def add_child(node)
+            @_children << node
+            return self
+        end
+
+        def <<(data)
+        	case data
+        	when Hash
+        		data.each{|k,v|
+        			k = k.to_s if k.is_a? Symbol
+        			@_attributes[k] = v
+        		}
+        	when KXML::Node
+        		add_child(data)
+        	when String 
+        		if data =~ /^[<>\/]/
+        			self << Node.new(data)
+        		else
+        			append_content(data)
+        		end
+        	when Symbol
+        		append_content(data.to_s)
+        	when Array
+        		data.each{|e|
+        			self << e
+        		}
+        	else
+        		raise "method << not support this type : #{data.class}"
+        	end
+            return self
+        end
+        
+        def append_content(data)
+        	@_content = "" if @_content == nil
+        	@_content += data
+        end
+    	
+        def to_ary
+            return [] << to_s
+        end
+
+        def to_s(format = Format::MINIMUM)
+        	case format
+        	when Format::MINIMUM
+	            attributes_str = ""
+	            @_attributes.each{|key,value|
+	                attributes_str += " #{key}=\"#{value}\""
+	            }
+	            content = ""
+	            @_children.each{|child|
+	                content += child.to_s
+	            }
+	            content += @_content if @_content != nil
+	            return "<#{@_name}#{attributes_str}>#{content}</#{@_name}>"
+	        when Format::PRETTY
+	        	return _to_s_pretty
+	        else
+	        	raise "Unsupport Format : #{format}"
+	        end
+        end
+        
+        def _to_s_pretty(deepth = 0)
+            attributes_str = ""
+            indent = "\t" * deepth
+            wrap = "\n"
+            @_attributes.each{|key,value|
+                attributes_str += " #{key}=\"#{value}\""
+            }
+            content = ""
+            @_children.each{|child|
+            	content += wrap
+                content += child._to_s_pretty(deepth+1)
+            }
+            content += wrap if @_children.size > 0
+            content += @_content if @_content != nil
+            return "#{indent}<#{@_name}#{attributes_str}>#{content}#{@_children.size > 0 ? indent : ""}</#{@_name}>"
+        end
+        
+        # getter setter
+
+        def [](key)
+            return @_attributes[key.to_s]
+        end
+
+        def []=(key,value)
+            @_attributes[key.to_s] = value
+        end
+        
+        def attributes
+        	return @_attributes
+        end
+        
+        def content
+            return @_content
+        end
+
+        def content=(value)
+            @_content = value
+        end
+
+        def name
+            return @_name
+        end
+
+        def name=(value)
+            @_name = value
+        end
+        
+        def children
+        	return @_children
+        end
+        
+        private
+        
+        def parse_from_string(data)
+        	document = Document.new(data)
+        	@_name = document.root.name
+        	@_children = document.root.children
+        	@_content = document.root.content
+        	@_attributes = document.root.attributes
+        end
+        
+        def parse_from_file(file)
+        	document = Document.new(file)
+        	@_name = document.root.name
+        	@_children = document.root.children
+        	@_content = document.root.content
+        	@_attributes = document.root.attributes
+        end
+
+        def find_children_by_name(name)
+            ret = []
+            @_children.each{|child|
+                ret << child if name.to_s == child.name.to_s
+            }
+            return nil if ret.size == 0
+            return ret[0] if ret.size == 1
+            return ret
+        end
+
+        def method_missing(method_name,*args,&block)
+        	super if args.size != 0
+            child = find_children_by_name(method_name)
+            raise "<#{@_name}> have not this child : <#{method_name}>" if child == nil
+            return child
+        end
+
+    end
+    
+    class Format
+    	MINIMUM = 'minimum'
+    	PRETTY	= 'pretty'
+    end
+
+end
+

data/lib/xml/xml_parser.rb

@@ -0,0 +1,114 @@
+module KXML
+    class SAXParser
+        START_TAG			= 'START_TAG'
+        END_TAG				= 'END_TAG'
+        COMMENTS			= 'COMMENTS'
+        SELF_CLOSE_TAG		= 'SELF_COLSE_TAG'
+        DOCUMENT_STATEMENT	= 'DOCUMENT_STATEMENT'
+        CONTENT				= 'CONTENT'
+
+        attr_accessor :handler
+        def initialize
+            reset()
+        end
+
+        def reset
+            @state = :NONE
+            @temp_str = nil
+            @is_start_tag = true
+            @quote_state = nil
+            @data = ''
+            @end = false
+        end
+
+        def <<(data)
+            push(data)
+        end
+
+        def push(data)
+            @data += data
+            parse()
+        end
+
+        def end
+            @end = true
+            parse()
+        end
+
+        private
+
+        def parse
+            raise "Cannot parse without handler" if @handler == nil
+            return if @data == nil || @data == ''
+
+            while(true)
+                result = @data.match(/^<([\s\S.]*?)>/)
+                if result !=nil && @data[0] == '<'
+                    dispath_tag(result.to_s)
+                    @data = @data[result[1].size+2,@data.size]
+                	next
+                end
+                result = @data.match(/([\s\S.]+?)</)
+                if result !=nil
+                    dispath_content(result[1])
+                    @data = @data[result[1].size,@data.size]
+                	next
+                end
+                break
+            end
+            dispath_content(@data) if @end && @data != nil && @data != ''
+        end
+
+        def dispath_tag(data)
+            if data =~ /<\?xml\s+(.*?)\?>/
+            	param = parse_tag("STATEMENT #{data.match(/<\?xml\s+(.*?)\?>/)[1]}")
+            	param[:type] = DOCUMENT_STATEMENT
+                @handler.call(param)
+            return
+            end
+            if data =~ /<([\s\S.]*?)\/>/
+            	param = parse_tag(data.match(/<([\s\S.]*?)\/>/)[1])
+            	param[:type] = SELF_CLOSE_TAG
+                @handler.call(param)
+            return
+            end
+            if data =~ /<\/([\s\S.]*?)>/
+            	param = parse_tag(data.match(/<\/([\s\S.]*?)>/)[1])
+            	param[:type] = END_TAG
+                @handler.call(param)
+            return
+            end
+            if data =~ /<\!--([\s\S.]*?)-->/
+                @handler.call({:type => COMMENTS , :name => data.match(/<\!--([\s\S.]*?)-->/)[1]})
+            return
+            end
+        	param = parse_tag(data.match(/<([\s\S.]*?)>/)[1])
+        	param[:type] = START_TAG
+            @handler.call(param)
+        end
+
+        def dispath_content(data)
+            @handler.call({:type => CONTENT , :name => data})
+        end
+
+        def parse_tag(data)
+            arr = data.split(' ')
+            if arr.size == 1
+                return {:name => arr[0]}
+            else
+            	ret = {}
+            	ret[:name] = arr[0]
+                ret[:attributes] = {}
+                1.upto(arr.size-1){|index|
+                    attribute = arr[index]
+                    attribute_arr = attribute.split('=')
+                    raise "Parse Attribute Failed : #{attribute}" if attribute_arr.size!=2 || !attribute_arr[1].match(/[\'\"](.*)[\'\"]/)
+                    ret[:attributes].store(attribute_arr[0],attribute_arr[1].match(/[\'\"](.*)[\'\"]/)[1])
+                }
+                return ret
+            end
+        end
+
+    end
+
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: khrl
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Koihik
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-14 00:00:00.000000000 Z
+dependencies: []
+description: private ruby lib
+email: koihik@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- khrl-0.0.1.gem
+- khrl.gemspec
+- lib/file/kfile.rb
+- lib/khrl.rb
+- lib/xml/kxml.rb
+- lib/xml/xml_parser.rb
+homepage: https://rubygems.org/gems/khrl
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: KHRL
+test_files: []