eim_xml 0.0.4 → 1.0.0

data/lib/eim_xml/formatter.rb

@@ -1,123 +1,122 @@
-require "eim_xml"
+require 'eim_xml'
 
 module EimXML
-	class Formatter
-		attr_reader :out
+  class Formatter
+    attr_reader :out
 
-		def self.write(element, opt={})
-			opt = {:out=>""}.merge(opt)
-			new(opt).write(element)
-			opt[:out]
-		end
+    def self.write(element, opt = {})
+      opt = { out: '' }.merge(opt)
+      new(opt).write(element)
+      opt[:out]
+    end
 
-		def initialize(opt)
-			@out = opt[:out]
-			@preservers = opt[:preservers]
-			@preserve_space = false
-			@indent_string = "  "
-			@indent_depth = 0
-			@option = opt.dup.tap{|h| [:out, :preservers].each{|k| h.delete(k)}}
-		end
+    def initialize(opt)
+      @out = opt[:out]
+      @preservers = opt[:preservers]
+      @preserve_space = false
+      @indent_string = '  '
+      @indent_depth = 0
+      @option = opt.dup.tap { |h| %i[out preservers].each { |k| h.delete(k) } }
+    end
 
-		def write(src)
-			case src
-			when ElementWrapper
-				write_wrapper(src)
-			when Comment
-				write_comment(src)
-			when Element
-				write_element(src)
-			when PCString
-				write_pcstring(src)
-			else
-				write_string(src.to_s)
-			end
-		end
+    def write(src)
+      case src
+      when ElementWrapper
+        write_wrapper(src)
+      when Comment
+        write_comment(src)
+      when Element
+        write_element(src)
+      when PCString
+        write_pcstring(src)
+      else
+        write_string(src.to_s)
+      end
+    end
 
-		def indent(&proc)
-			@indent_depth += 1
-			proc.call
-		ensure
-			@indent_depth -= 1
-		end
+    def indent(&proc)
+      @indent_depth += 1
+      proc.call
+    ensure
+      @indent_depth -= 1
+    end
 
-		def preserve_space_element?(elm)
-			@preservers && @preservers.any? do |e|
-				case e
-				when Symbol
-					e==elm.name
-				when Class
-					e===elm
-				end
-			end
-		end
+    def preserve_space_element?(elm)
+      @preservers&.any? do |e|
+        case e
+        when Symbol
+          e == elm.name
+        when Class
+          elm.is_a?(e)
+        end
+      end
+    end
 
-		def write_indent
-			out << @indent_string*@indent_depth unless @preserve_space
-		end
+    def write_indent
+      out << (@indent_string * @indent_depth) unless @preserve_space
+    end
 
-		def write_newline
-			out << "\n" unless @preserve_space
-		end
+    def write_newline
+      out << "\n" unless @preserve_space
+    end
 
-		def write_comment(c)
-			write_indent
-			c.write_to(out)
-			write_newline
-		end
+    def write_comment(commend)
+      write_indent
+      commend.write_to(out)
+      write_newline
+    end
 
-		def write_contents_of(elm)
-			flag = @preserve_space
-			@preserve_space = true if preserve_space_element?(elm)
-			write_newline
-			indent do
-				elm.contents.each do |c|
-					write(c)
-				end
-			end
-			write_indent
-		ensure
-			@preserve_space = flag
-		end
+    def write_contents_of(elm)
+      flag = @preserve_space
+      @preserve_space = true if preserve_space_element?(elm)
+      write_newline
+      indent do
+        elm.contents.each do |c|
+          write(c)
+        end
+      end
+      write_indent
+    ensure
+      @preserve_space = flag
+    end
 
-		def write_element(elm)
-			write_indent
-			out << "<"
-			elm.name_and_attributes(out)
-			case elm.contents.size
-			when 0
-				out << " />"
-				write_newline
-			else
-				out << ">"
-				write_contents_of(elm)
-				out << "</#{elm.name}>"
-				write_newline
-			end
-		end
+    def write_element(elm)
+      write_indent
+      out << '<'
+      elm.name_and_attributes(out)
+      case elm.contents.size
+      when 0
+        out << ' />'
+      else
+        out << '>'
+        write_contents_of(elm)
+        out << "</#{elm.name}>"
+      end
+      write_newline
+    end
 
-		def write_pcstring(pcs)
-			pcs.encoded_string.each_line do |l|
-				write_indent
-				out << l
-			end
-			write_newline
-		end
+    def write_pcstring(pcs)
+      pcs.encoded_string.each_line do |l|
+        write_indent
+        out << l
+      end
+      write_newline
+    end
 
-		def write_string(str)
-			PCString.encode(str).each_line do |l|
-				write_indent
-				out << l
-			end
-			write_newline
-		end
+    def write_string(str)
+      PCString.encode(str).each_line do |l|
+        write_indent
+        out << l
+      end
+      write_newline
+    end
 
-		def write_wrapper(wrapper)
-			wrapper.each(@option) do |i|
-				write(i)
-			end
-		end
-	end
+    def write_wrapper(wrapper)
+      wrapper.each(@option) do |i|
+        write(i)
+      end
+    end
+  end
 end
 
-require "eim_xml/formatter/element_wrapper"
+require 'eim_xml/formatter/element_wrapper'

data/lib/eim_xml/matcher.rb

@@ -1,25 +1,28 @@
-require "eim_xml"
-module EimXML::Matchers
-	class HaveContent
-		def initialize(expected)
-			@expected = expected
-		end
+require 'eim_xml'
 
-		def matches?(target)
-			@target = target
-			@target.has?(@expected)
-		end
+module EimXML
+  module Matchers
+    class HaveContent
+      def initialize(expected)
+        @expected = expected
+      end
 
-		def failure_message
-			"expected #{@target.inspect} must have #{@expected}, but not."
-		end
+      def matches?(target)
+        @target = target
+        @target.has?(@expected)
+      end
 
-		def negative_failure_message
-			"expected #{@target.inspect} must not have #{@expected}, but has."
-		end
-	end
+      def failure_message
+        "expected #{@target.inspect} must have #{@expected}, but not."
+      end
 
-	def have(expected)
-		HaveContent.new(expected)
-	end
+      def negative_failure_message
+        "expected #{@target.inspect} must not have #{@expected}, but has."
+      end
+    end
+
+    def have(expected)
+      HaveContent.new(expected)
+    end
+  end
 end

data/lib/eim_xml/parser.rb

@@ -4,84 +4,82 @@
 # You can redistribute it and/or modify it under GPL2.
 #
 
-require "eim_xml"
-require "strscan"
+require 'eim_xml'
+require 'strscan'
 
 module EimXML
-	class ParseError < StandardError
-	end
+  class ParseError < StandardError
+  end
 
-	class Parser
-		attr_reader :scanner
-		module RE
-			EMPTY_ELEMENT = /<([^>]*?)\/>/
-			START_TAG = /<([^>]*?([^\/>]\s*))>/
-			END_TAG = /<\/(\S+?)\s*>/
-			ATTRIBUTE = /\s+([^=\s]+)\s*=\s*('(.*?)'|"(.*?)")/m
-			STRING = /[^<]+/
-		end
+  class Parser
+    attr_reader :scanner
 
-		def initialize(src)
-			@scanner = StringScanner.new(src)
-			@scanner.scan(/\s*<\?.*?\?>\s*/)
-		end
+    module RE
+      EMPTY_ELEMENT = %r{<([^>]*?)/>}
+      START_TAG = %r{<([^>]*?([^/>]\s*))>}
+      END_TAG = %r{</(\S+?)\s*>}
+      ATTRIBUTE = /\s+([^=\s]+)\s*=\s*('(.*?)'|"(.*?)")/m
+      STRING = /[^<]+/
+    end
 
-		def parse
-			if @scanner.scan(RE::EMPTY_ELEMENT)
-				parse_empty_element
-			elsif @scanner.scan(RE::START_TAG)
-				parse_start_tag
-			elsif @scanner.scan(RE::STRING)
-				parse_string
-			else
-				nil
-			end
-		end
+    PARSING_MAP = {
+      'amp' => '&',
+      'quot' => '"',
+      'apos' => "'",
+      'lt' => '<',
+      'gt' => '>'
+    }
 
-		def parse_tag
-			s = StringScanner.new(@scanner[1])
-			e = Element.new(s.scan(/\S+/))
-			e[s[1]] = s[3] ? s[3] : s[4] while s.scan(RE::ATTRIBUTE)
-			e
-		end
-		protected :parse_tag
+    def initialize(src)
+      @scanner = StringScanner.new(src)
+      @scanner.scan(/\s*<\?.*?\?>\s*/)
+    end
 
-		def parse_empty_element
-			parse_tag
-		end
-		protected :parse_empty_element
+    def parse
+      if @scanner.scan(RE::EMPTY_ELEMENT)
+        parse_empty_element
+      elsif @scanner.scan(RE::START_TAG)
+        parse_start_tag
+      elsif @scanner.scan(RE::STRING)
+        parse_string
+      end
+    end
 
-		def parse_start_tag
-			e = parse_tag
+    def parse_tag
+      s = StringScanner.new(@scanner[1])
+      e = Element.new(s.scan(/\S+/))
+      e[s[1]] = s[3] || s[4] while s.scan(RE::ATTRIBUTE)
+      e
+    end
+    protected :parse_tag
 
-			until @scanner.scan(RE::END_TAG)
-				c = parse
-				raise ParseError.new("Syntax error.") unless c
-				e << c
-			end
-			raise ParseError.new("End tag mismatched.") unless @scanner[1].to_sym==e.name
-			e
-		end
-		protected :parse_start_tag
+    def parse_empty_element
+      parse_tag
+    end
+    protected :parse_empty_element
 
-		def parse_string
-			s = @scanner[0]
-			s = s.gsub(/&(amp|quot|apos|lt|gt);/) do
-				case $1
-				when "amp"
-					"&"
-				when "quot"
-					'"'
-				when "apos"
-					"'"
-				when "lt"
-					"<"
-				when "gt"
-					">"
-				end
-			end
-			PCString.new(s)
-		end
-		protected :parse_string
-	end
+    def parse_start_tag
+      e = parse_tag
+
+      until @scanner.scan(RE::END_TAG)
+        c = parse
+        raise ParseError, 'Syntax error.' unless c
+
+        e << c
+      end
+      raise ParseError, 'End tag mismatched.' unless @scanner[1].to_sym == e.name
+
+      e
+    end
+    protected :parse_start_tag
+
+    def parse_string
+      s = @scanner[0]
+      s = s.gsub(/&(amp|quot|apos|lt|gt);/) do
+        PARSING_MAP[Regexp.last_match(1)]
+      end
+      PCString.new(s)
+    end
+    protected :parse_string
+  end
 end

data/lib/eim_xml/xhtml/dsl.rb

@@ -1,18 +1,20 @@
-require "eim_xml/dsl"
-require "eim_xml/xhtml"
+require 'eim_xml/dsl'
+require 'eim_xml/xhtml'
 
-module EimXML::XHTML
-	class DSL < EimXML::BaseDSL
-	end
+module EimXML
+  module XHTML
+    class DSL < EimXML::BaseDSL
+    end
 
-	class OpenDSL < EimXML::OpenDSL
-	end
+    class OpenDSL < EimXML::OpenDSL
+    end
 
-	constants.each do |c|
-		v = const_get(c)
-		if v.is_a?(Class) && /_$/ !~ v.name
-			DSL.register v
-			OpenDSL.register v
-		end
-	end
+    constants.each do |c|
+      v = const_get(c)
+      if v.is_a?(Class) && /_$/ !~ v.name
+        DSL.register v
+        OpenDSL.register v
+      end
+    end
+  end
 end