meteor 0.9.30 → 0.9.32

data/lib/meteor/core/kernel.rb

@@ -17,23 +17,23 @@ module Meteor
     class Kernel < Meteor::Parser
       # find
       # E
-      PATTERN_FIND_1 = "^([^,\\[\\]#\\.]+)$"
+      PATTERN_FIND_1 = '^([^,\\[\\]#\\.]+)$'
       # # id_attribute_value
-      PATTERN_FIND_2_1 = "^#([^\\.,\\[\\]#][^,\\[\\]#]*)$"
+      PATTERN_FIND_2_1 = '^#([^\\.,\\[\\]#][^,\\[\\]#]*)$'
       # .class_attribute_value
-      PATTERN_FIND_2_2 = "^\\.([^\\.,\\[\\]#][^,\\[\\]#]*)$"
+      PATTERN_FIND_2_2 = '^\\.([^\\.,\\[\\]#][^,\\[\\]#]*)$'
       # [attribute_name=attribute_value]
-      PATTERN_FIND_2_3 = "^\\[([^\\[\\],]+)=([^\\[\\],]+)\\]$"
+      PATTERN_FIND_2_3 = '^\\[([^\\[\\],]+)=([^\\[\\],]+)\\]$'
       # E[attribute_name=attribute_value]
-      PATTERN_FIND_3_1 = "^([^\\.,\\[\\]#][^,\\[\\]#]+)\\[([^,\\[\\]]+)=([^,\\[\\]]+)\\]$"
+      PATTERN_FIND_3_1 = '^([^\\.,\\[\\]#][^,\\[\\]#]+)\\[([^,\\[\\]]+)=([^,\\[\\]]+)\\]$'
       # E# id_attribute_value
-      PATTERN_FIND_3_2 = "^([^\\.,\\[\\]#][^,\\[\\]#]+)#([^\\.,\\[\\]#][^,\\[\\]#]*)$"
+      PATTERN_FIND_3_2 = '^([^\\.,\\[\\]#][^,\\[\\]#]+)#([^\\.,\\[\\]#][^,\\[\\]#]*)$'
       # E.class_attribute_value
-      PATTERN_FIND_3_3 = "^([^\\.,\\[\\]#][^,\\[\\]#]+)\\.([^\\.,\\[\\]#][^,\\[\\]#]*)$"
+      PATTERN_FIND_3_3 = '^([^\\.,\\[\\]#][^,\\[\\]#]+)\\.([^\\.,\\[\\]#][^,\\[\\]#]*)$'
       # [attribute_name1=attribute_value1][attribute_name2=attribute_value2]
-      PATTERN_FIND_4 = "^\\[([^,]+)=([^,]+)\\]\\[([^,]+)=([^,]+)\\]$"
+      PATTERN_FIND_4 = '^\\[([^,]+)=([^,]+)\\]\\[([^,]+)=([^,]+)\\]$'
       # E[attribute_name1=attribute_value1][attribute_name2=attribute_value2]
-      PATTERN_FIND_5 = "^([^\\.,\\[\\]#][^,\\[\\]#]+)\\[([^,]+)=([^,]+)\\]\\[([^,]+)=([^,]+)\\]$"
+      PATTERN_FIND_5 = '^([^\\.,\\[\\]#][^,\\[\\]#]+)\\[([^,]+)=([^,]+)\\]\\[([^,]+)=([^,]+)\\]$'
 
       @@pattern_find_1 = Regexp.new(PATTERN_FIND_1)
       @@pattern_find_2_1 = Regexp.new(PATTERN_FIND_2_1)
@@ -45,50 +45,47 @@ module Meteor
       @@pattern_find_4 = Regexp.new(PATTERN_FIND_4)
       @@pattern_find_5 = Regexp.new(PATTERN_FIND_5)
 
-      @@pattern_set_mono1 = Regexp.new("\\A[^<>]*\\Z")
+      @@pattern_set_mono1 = Regexp.new('\\A[^<>]*\\Z')
 
-      @@pattern_get_attrs_map = Regexp.new("([^\\s]*)=\"([^\\\"]*)\"")
+      @@pattern_get_attrs_map = Regexp.new('([^\\s]*)="([^\"]*)"')
 
-      @@pattern_clean1 = Regexp.new("<!--\\s@[^<>]*\\s[^<>]*(\\s)*-->")
-      @@pattern_clean2 = Regexp.new("<!--\\s\\/@[^<>]*(\\s)*-->")
+      @@pattern_clean1 = Regexp.new('<!--\\s@[^<>]*\\s[^<>]*(\\s)*-->')
+      @@pattern_clean2 = Regexp.new('<!--\\s\\/@[^<>]*(\\s)*-->')
 
-      BR = "<br>"
+      BR = '<br>'
       BR_RE = BR
 
       TABLE_FOR_ESCAPE_ = {
-        "&" => "&amp;",
-        "\"" => "&quot;",
-        "'" => "&apos;",
-        "<" => "&lt;",
-        ">" => "&gt;",
-        " " => "&nbsp;"
-      }
+        '&' => '&amp;',
+        '"' => '&quot;',
+        "'" => '&apos;',
+        '<' => '&lt;',
+        '>' => '&gt;',
+        ' ' => '&nbsp;'
+      }.freeze
 
       TABLE_FOR_ESCAPE_CONTENT_ = {
-        "&" => "&amp;",
-        "\"" => "&quot;",
-        "'" => "&apos;",
-        "<" => "&lt;",
-        ">" => "&gt;",
-        " " => "&nbsp;",
+        '&' => '&amp;',
+        '"' => '&quot;',
+        "'" => '&apos;',
+        '<' => '&lt;',
+        '>' => '&gt;',
+        ' ' => '&nbsp;',
         "\r\n" => BR,
         "\r" => BR,
         "\n" => BR
-      }
+      }.freeze
 
       PATTERN_ESCAPE = "[&\"'<> ]"
       PATTERN_ESCAPE_CONTENT = "[&\"'<> \\n]"
       @@pattern_escape = Regexp.new(PATTERN_ESCAPE)
       @@pattern_escape_content = Regexp.new(PATTERN_ESCAPE_CONTENT)
 
-      PATTERN_UNESCAPE = "&(amp|quot|apos|gt|lt|nbsp);"
+      PATTERN_UNESCAPE = '&(amp|quot|apos|gt|lt|nbsp);'
       @@pattern_unescape = Regexp.new(PATTERN_UNESCAPE)
       @@pattern_br_2 = Regexp.new(BR_RE)
 
-      attr_accessor :element_cache
-      attr_accessor :doc_type
-      attr_accessor :document_hook
-      attr_accessor :element_hook
+      attr_accessor :element_cache, :doc_type, :document_hook, :element_hook
 
       #
       # set document (ドキュメントをセットする)
@@ -97,6 +94,8 @@ module Meteor
       #
       def document=(doc)
         @root.document = doc
+
+        parse
       end
 
       #
@@ -115,7 +114,7 @@ module Meteor
         @root.enc = enc
       end
 
-      alias_method :character_encoding=, :enc=
+      alias character_encoding= enc=
 
       #
       # get character encoding (文字エンコーディングを取得する)
@@ -125,7 +124,7 @@ module Meteor
         @root.enc
       end
 
-      alias_method :character_encoding, :enc
+      alias character_encoding enc
 
       #
       # get root element (ルート要素を取得する)
@@ -148,9 +147,9 @@ module Meteor
         @root = RootElement.new
         @root.parser = self
         # element cache (要素キャッシュ)
-        @element_cache = Hash.new
+        @element_cache = {}
         # document hook (フック・ドキュメント)
-        @document_hook = String.new("")
+        @document_hook = String.new('')
 
         @error_check = true
       end
@@ -161,35 +160,20 @@ module Meteor
       # @param [String] enc character encoding of input file (入力ファイルの文字コード)
       #
       def read(file_path, enc)
-        # try {
         self.enc = enc
-        mode = if enc == "UTF-8"
-          # String.new("") << "r:" << enc
-          "r:UTF-8"
-        else
-          String.new("") << "r:" << enc << ":utf-8"
-        end
-
-        # open file (ファイルのオープン)
-        io = File.open(file_path, mode)
 
-        # load and save (読込及び格納)
-        @root.document = io.read
+        self.document = Meteor::Core::Util::FileReader.read(file_path, enc)
 
-        # close file (ファイルのクローズ)
-        io.close
-
-        parse
-
-        return @root.document
+        @root.document
       end
 
       #
       # psrse document (ドキュメントを解析する)
       # @param [String] document document (ドキュメント)
       #
-      def parse
-      end
+      def parse; end
+
+      protected :parse
 
       #
       # get element (要素を取得する)
@@ -239,68 +223,51 @@ module Meteor
       #
       def element(elm, attrs = nil, *args)
         if !attrs
-          if elm.kind_of?(String) || elm.kind_of?(Symbol)
-            element_1(elm.to_s)
-            if @elm_
-              @element_cache.store(@elm_.object_id, @elm_)
-            end
-          elsif elm.kind_of?(Meteor::Element)
+          case elm
+          when String, Symbol
+            element_one(elm.to_s)
+            @element_cache.store(@elm_.object_id, @elm_) if @elm_
+          when Meteor::Element
             shadow(elm)
-          elsif elm.kind_of?(Hash)
+          when Hash
             if elm.size == ONE
-              element_2(elm.keys[0].to_s, elm.values[0])
-              if @elm_
-                @element_cache.store(@elm_.object_id, @elm_)
-              end
+              element_two(elm.keys[0].to_s, elm.values[0])
+              @element_cache.store(@elm_.object_id, @elm_) if @elm_
             elsif elm.size == TWO
-              element_4(elm.keys[0].to_s, elm.values[0], elm.keys[1].to_s, elm.values[1])
-              if @elm_
-                @element_cache.store(@elm_.object_id, @elm_)
-              end
+              element_four(elm.keys[0].to_s, elm.values[0], elm.keys[1].to_s, elm.values[1])
+              @element_cache.store(@elm_.object_id, @elm_) if @elm_
             else
               raise ArgumentError
             end
           else
             raise ArgumentError
           end
-        elsif attrs.kind_of?(Hash)
+        elsif attrs.is_a?(Hash)
           if attrs.size == ONE
-            element_3(elm.to_s, attrs.keys[0].to_s, attrs.values[0])
-            if @elm_
-              @element_cache.store(@elm_.object_id, @elm_)
-            end
+            element_three(elm.to_s, attrs.keys[0].to_s, attrs.values[0])
+            @element_cache.store(@elm_.object_id, @elm_) if @elm_
           elsif attrs.size == TWO
-            element_5(elm.to_s, attrs.keys[0].to_s, attrs.values[0], attrs.keys[1].to_s, attrs.values[1])
-            if @elm_
-              @element_cache.store(@elm_.object_id, @elm_)
-            end
+            element_five(elm.to_s, attrs.keys[0].to_s, attrs.values[0], attrs.keys[1].to_s, attrs.values[1])
+            @element_cache.store(@elm_.object_id, @elm_) if @elm_
           else
             @elm_ = nil
             raise ArgumentError
           end
-        elsif attrs.kind_of?(String) || attrs.kind_of?(Symbol)
+        elsif attrs.is_a?(String) || attrs.is_a?(Symbol)
           case args.length
           when ZERO
-            element_2(elm.to_s, attrs.to_s)
-            if @elm_
-              @element_cache.store(@elm_.object_id, @elm_)
-            end
+            element_two(elm.to_s, attrs.to_s)
+            @element_cache.store(@elm_.object_id, @elm_) if @elm_
 
           when ONE
-            element_3(elm.to_s, attrs.to_s, args[0])
-            if @elm_
-              @element_cache.store(@elm_.object_id, @elm_)
-            end
+            element_three(elm.to_s, attrs.to_s, args[0])
+            @element_cache.store(@elm_.object_id, @elm_) if @elm_
           when TWO
-            element_4(elm.to_s, attrs.to_s, args[0].to_s, args[1])
-            if @elm_
-              @element_cache.store(@elm_.object_id, @elm_)
-            end
+            element_four(elm.to_s, attrs.to_s, args[0].to_s, args[1])
+            @element_cache.store(@elm_.object_id, @elm_) if @elm_
           when THREE
-            element_5(elm.to_s, attrs.to_s, args[0], args[1].to_s, args[2])
-            if @elm_
-              @element_cache.store(@elm_.object_id, @elm_)
-            end
+            element_five(elm.to_s, attrs.to_s, args[0], args[1].to_s, args[2])
+            @element_cache.store(@elm_.object_id, @elm_) if @elm_
           else
             @elm_ = nil
             raise ArgumentError
@@ -316,7 +283,7 @@ module Meteor
       # @param [String,Symbol] name tag name (タグ名)
       # @return [Meteor::Element] element(要素)
       #
-      def element_1(name)
+      def element_one(name)
         quote_name(name)
 
         # element search pattern (要素検索用パターン)
@@ -328,10 +295,10 @@ module Meteor
 
         if @res
           if @res[1]
-            element_void_1(name)
+            element_void_one(name)
           else
             # puts '---element_normal_1'
-            element_normal_1(name)
+            element_normal_one(name)
           end
           # else
         end
@@ -339,29 +306,28 @@ module Meteor
         @elm_
       end
 
-      private :element_1
+      private :element_one
 
-      def element_normal_1(name)
+      def element_normal_one(name)
         @elm_ = Meteor::Element.new(name)
 
-        unless @on_search
-          # puts '--on_search=false'
-          # puts @res.to_a
+        if @on_search
+          # puts '--on_search=true'
           # attribute (属性)
-          @elm_.attributes = @res[2]
+          @elm_.attributes = @res[1]
           # content (内容)
-          @elm_.mixed_content = @res[3]
+          @elm_.mixed_content = @res[2]
           # document (全体)
-          @elm_.document = @res[0]
         else
-          # puts '--on_search=true'
+          # puts '--on_search=false'
+          # puts @res.to_a
           # attribute (属性)
-          @elm_.attributes = @res[1]
+          @elm_.attributes = @res[2]
           # content (内容)
-          @elm_.mixed_content = @res[2]
+          @elm_.mixed_content = @res[3]
           # document (全体)
-          @elm_.document = @res[0]
         end
+        @elm_.document = @res[0]
         # normal element search pattern (内容あり要素検索用パターン)
         # @pattern_cc = String.new('') << "<" << @_name << '(?:|\\s[^<>]*)>((?!(' << @_name
         # @pattern_cc << '[^<>]*>)).)*<\\/' << @_name << '>'
@@ -374,9 +340,9 @@ module Meteor
         @elm_
       end
 
-      private :element_normal_1
+      private :element_normal_one
 
-      def element_void_1(name)
+      def element_void_one(name)
         # element (要素)
         @elm_ = Meteor::Element.new(name)
         # attribute (属性)
@@ -384,7 +350,7 @@ module Meteor
         # document (全体)
         @elm_.document = @res[0]
         # void element search pattern (空要素検索用パターン)
-        @pattern_cc = String.new("") << "<" << @_name << "(|\\s[^<>]*)\\/>"
+        @pattern_cc = String.new('') << '<' << @_name << '(|\\s[^<>]*)\\/>'
         # @pattern_cc = "<#{@_name}(|\\s[^<>]*)\\/>"
         @elm_.pattern = @pattern_cc
 
@@ -395,7 +361,7 @@ module Meteor
         @elm_
       end
 
-      private :element_void_1
+      private :element_void_one
 
       #
       # get element using tag name and attribute(name="value") (要素のタグ名と属性(属性名="属性値")で検索し、要素を取得する)
@@ -404,20 +370,20 @@ module Meteor
       # @param [String] attr_value attribute value (属性値)
       # @param [true,false] quote flag (クオート・フラグ)
       # @return [Meteor::Element] element (要素)
-      def element_3(name, attr_name, attr_value, quote = true)
+      def element_three(name, attr_name, attr_value, quote = true)
         if quote
-          quote_element_3(name, attr_name, attr_value)
+          quote_element_three(name, attr_name, attr_value)
         else
           quote_name(name)
         end
 
-        @pattern_cc_1 = element_pattern_3
+        @pattern_cc_1 = element_pattern_three
 
         @pattern = Meteor::Core::Util::PatternCache.get(@pattern_cc_1)
         @res1 = @pattern.match(@root.document)
 
         if @res1 && @res1[1] || !@res1
-          @res2 = element_normal_3_2
+          @res2 = element_normal_three_two
           @pattern_cc_2 = @pattern_cc
 
           # puts @res2.captures.length
@@ -429,31 +395,29 @@ module Meteor
             @res = @res1
             # @pattern_cc = @pattern_cc_1
             if @res[1]
-              element_void_3(name)
+              element_void_three(name)
             else
-              element_normal_3_1(name)
+              element_normal_three_one(name)
             end
           elsif @res1.begin(0) > @res2.begin(0)
             @res = @res2
             # @pattern_cc = @pattern_cc_2
-            element_normal_3_1(name)
+            element_normal_three_one(name)
           end
         elsif @res1 && !@res2
           @res = @res1
           # @pattern_cc = @pattern_cc_1
           if @res[1]
-            element_void_3(name)
+            element_void_three(name)
           else
-            element_normal_3_1(name)
+            element_normal_three_one(name)
           end
         elsif @res2 && !@res1
           @res = @res2
           # @pattern_cc = @pattern_cc_2
-          element_normal_3_1(name)
+          element_normal_three_one(name)
         else
-          if @error_check
-            puts(Meteor::Exception::NoSuchElementException.new(name, attr_name, attr_value).message)
-          end
+          puts(Meteor::Exception::NoSuchElementException.new(name, attr_name, attr_value).message) if @error_check
 
           @elm_ = nil
         end
@@ -461,22 +425,22 @@ module Meteor
         @elm_
       end
 
-      private :element_3
+      private :element_three
 
-      def element_pattern_3
+      def element_pattern_three
         "<#{@_name}(\\s[^<>]*#{@_attr_name}=\"#{@_attr_value}\"[^<>]*)\\/>|<#{@_name}(\\s[^<>]*#{@_attr_name}=\"#{@_attr_value}\"[^<>]*)>(((?!(#{@_name}[^<>]*>)).)*)<\\/#{@_name}>"
       end
 
-      private :element_pattern_3
+      private :element_pattern_three
 
-      def quote_element_3(name, attr_name, attr_value)
+      def quote_element_three(name, attr_name, attr_value)
         quote_name(name)
         quote_attribute(attr_name, attr_value)
       end
 
-      private :quote_element_3
+      private :quote_element_three
 
-      def element_normal_3_1(name)
+      def element_normal_three_one(name)
         # puts  @res.captures.length
         case @res.captures.length
         when FOUR
@@ -523,17 +487,15 @@ module Meteor
         when THREE, SIX
           # element (要素)
           @elm_ = Meteor::Element.new(name)
-          unless @on_search
-            # attribute (属性)
-            @elm_.attributes = @res[1].chop
-            # content (内容)
-            @elm_.mixed_content = @res[3]
-          else
-            # attribute (属性)
-            @elm_.attributes = @res[1].chop
-            # content (内容)
-            @elm_.mixed_content = @res[3]
-          end
+          @elm_.attributes = @res[1].chop
+          # if @on_search
+          # # attribute (属性)
+          # # content (内容)
+          # else
+          #   # attribute (属性)
+          #   # content (内容)
+          # end
+          @elm_.mixed_content = @res[3]
           # document (全体)
           @elm_.document = @res[0]
           #  normal element search pattern (内容あり要素検索用パターン)
@@ -547,14 +509,12 @@ module Meteor
         @elm_
       end
 
-      private :element_normal_3_1
+      private :element_normal_three_one
 
-      def element_normal_3_2
-        element_pattern_normal_3_2
+      def element_normal_three_two
+        element_pattern_normal_three_two
 
-        if @sbuf.length == ZERO || @cnt != ZERO
-          return nil
-        end
+        return nil if @sbuf.length == ZERO || @cnt != ZERO
 
         @pattern = Meteor::Core::Util::PatternCache.get(@pattern_cc)
         @res = @pattern.match(@root.document)
@@ -562,31 +522,31 @@ module Meteor
         @res
       end
 
-      private :element_normal_3_2
+      private :element_normal_three_two
 
-      def element_pattern_normal_3_2
+      def element_pattern_normal_three_two
         # @pattern_cc_1 = String.new('') << "<" << @_name << '(\\s[^<>]*' << @_attr_name << '="'
         # @pattern_cc_1 << @_attr_value << '(?:[^<>\\/]*>|(?:(?!([^<>]*\\/>))[^<>]*>)))'
         @pattern_cc_1 = "<#{@_name}(\\s[^<>]*#{@_attr_name}=\"#{@_attr_value}(?:[^<>\\/]*>|(?:(?!([^<>]*\\/>))[^<>]*>)))"
-        @pattern_cc_1b = String.new("") << "<" << @_name << "(\\s[^<>\\/]*>|((?!([^<>]*\\/>))[^<>]*>))"
+        @pattern_cc_1b = String.new('') << '<' << @_name << '(\\s[^<>\\/]*>|((?!([^<>]*\\/>))[^<>]*>))'
         # @pattern_cc_1b = "<#{@_name}(\\s[^<>\\/]*>|((?!([^<>]*\\/>))[^<>]*>))"
         # @pattern_cc_1_1 = String.new('') << "<" << @_name << '(\\s[^<>]*' << @_attr_name << '="'
         # @pattern_cc_1_1 << @_attr_value << '"(?:[^<>\\/]*>|(?!([^<>]*\\/>))[^<>]*>))('
         @pattern_cc_1_1 = "<#{@_name}(\\s[^<>]*#{@_attr_name}=\"#{@_attr_value}\"(?:[^<>\\/]*>|(?!([^<>]*\\/>))[^<>]*>))("
-        @pattern_cc_1_2 = String.new("") << ".*?<" << @_name << "(\\s[^<>\\/]*>|((?!([^<>]*\\/>))[^<>]*>))"
+        @pattern_cc_1_2 = String.new('') << '.*?<' << @_name << '(\\s[^<>\\/]*>|((?!([^<>]*\\/>))[^<>]*>))'
         # @pattern_cc_1_2 = ".*?<#{@_name}(\\s[^<>\\/]*>|((?!([^<>]*\\/>))[^<>]*>))"
 
-        @pattern_cc_2 = String.new("") << "<\\/" << @_name << ">"
+        @pattern_cc_2 = String.new('') << '<\\/' << @_name << '>'
         # @pattern_cc_2 = String.new('') << "<\\/#{@_name}>"
-        @pattern_cc_2_1 = String.new("") << ".*?<\\/" << @_name << ">"
+        @pattern_cc_2_1 = String.new('') << '.*?<\\/' << @_name << '>'
         # @pattern_cc_2_1 = ".*?<\\/#{@_name}>"
-        @pattern_cc_2_2 = String.new("") << ".*?)<\\/" << @_name << ">"
+        @pattern_cc_2_2 = String.new('') << '.*?)<\\/' << @_name << '>'
         # @pattern_cc_2_2 = ".*?)<\\/#{@_name}>"
 
         # search of normal element (内容あり要素検索)
         @pattern = Meteor::Core::Util::PatternCache.get(@pattern_cc_1)
 
-        @sbuf = String.new("")
+        @sbuf = String.new('')
 
         @pattern_2 = Meteor::Core::Util::PatternCache.get(@pattern_cc_2)
         @pattern_1b = Meteor::Core::Util::PatternCache.get(@pattern_cc_1b)
@@ -598,15 +558,15 @@ module Meteor
         @pattern_cc = @sbuf
       end
 
-      private :element_pattern_normal_3_2
+      private :element_pattern_normal_three_two
 
-      def element_void_3(name)
-        element_void_3_1(name, "\"[^<>]*)\\/>")
+      def element_void_three(name)
+        element_void_three_one(name, '"[^<>]*)\\/>')
       end
 
-      private :element_void_3
+      private :element_void_three
 
-      def element_void_3_1(name, closer)
+      def element_void_three_one(name, closer)
         # element (要素)
         @elm_ = Meteor::Element.new(name)
         # attribute (属性)
@@ -622,7 +582,7 @@ module Meteor
         @elm_
       end
 
-      private :element_void_3_1
+      private :element_void_three_one
 
       #
       # get element using attribute(name="value") (属性(属性名="属性値")で検索し、要素を取得する)
@@ -630,76 +590,72 @@ module Meteor
       # @param [String] attr_value attribute value (属性値)
       # @return [Meteor::Element] element (要素)
       #
-      def element_2(attr_name, attr_value)
+      def element_two(attr_name, attr_value)
         quote_attribute(attr_name, attr_value)
 
-        element_pattern_2
+        element_pattern_two
 
         @pattern = Meteor::Core::Util::PatternCache.get(@pattern_cc)
         @res = @pattern.match(@root.document)
 
         if @res
-          element_3(@res[1], attr_name, attr_value)
+          element_three(@res[1], attr_name, attr_value)
         else
-          if @error_check
-            puts(Meteor::Exception::NoSuchElementException.new(attr_name, attr_value).message)
-          end
+          puts(Meteor::Exception::NoSuchElementException.new(attr_name, attr_value).message) if @error_check
 
           @elm_ = nil
         end
 
-=begin
-        @pattern_cc_1 = "<([^<>\"]*)(\\s[^<>]*#{@_attr_name}=\"#{@_attr_value}\"[^<>]*)\\/>|<([^<>\"]*)(\\s[^<>]*#{@_attr_name}=\"#{@_attr_value}\"[^<>]*)>(((?!(\\3[^<>]*>)).)*)<\\/\\3>"
-
-        @pattern = Meteor::Core::Util::PatternCache.get(@pattern_cc_1)
-        @res1 = @pattern.match(@root.document)
-
-        if @res1 && @res1[1] || !@res1
-          @res2 = element_normal_2_2
-          @pattern_cc_2 = @pattern_cc
-
-          # puts @res2.captures.length
-          # puts @res2.regexp.to_s
-        end
-
-        if @res1 && @res2
-          if @res1.begin(0) < @res2.begin(0)
-            @res = @res1
-            # @pattern_cc = @pattern_cc_1
-            if @res[1]
-              element_void_2
-            else
-              element_normal_2_1
-            end
-          elsif @res1.begin(0) > @res2.begin(0)
-            @res = @res2
-            # @pattern_cc = @pattern_cc_2
-            element_normal_2_1
-          end
-        elsif @res1 && !@res2
-          @res = @res1
-          # @pattern_cc = @pattern_cc_1
-          if @res[1]
-            element_void_2
-          else
-            element_normal_2_1
-          end
-        elsif @res2 && !@res1
-          @res = @res2
-          # @pattern_cc = @pattern_cc_2
-          element_normal_2_1
-        else
-          if @error_check
-            puts Meteor::Exception::NoSuchElementException.new(attr_name, attr_value).message
-          end
-          @elm_ = nil
-        end
-=end
+        #         @pattern_cc_1 = "<([^<>\"]*)(\\s[^<>]*#{@_attr_name}=\"#{@_attr_value}\"[^<>]*)\\/>|<([^<>\"]*)(\\s[^<>]*#{@_attr_name}=\"#{@_attr_value}\"[^<>]*)>(((?!(\\3[^<>]*>)).)*)<\\/\\3>"
+        #
+        #         @pattern = Meteor::Core::Util::PatternCache.get(@pattern_cc_1)
+        #         @res1 = @pattern.match(@root.document)
+        #
+        #         if @res1 && @res1[1] || !@res1
+        #           @res2 = element_normal_two_two
+        #           @pattern_cc_2 = @pattern_cc
+        #
+        #           # puts @res2.captures.length
+        #           # puts @res2.regexp.to_s
+        #         end
+        #
+        #         if @res1 && @res2
+        #           if @res1.begin(0) < @res2.begin(0)
+        #             @res = @res1
+        #             # @pattern_cc = @pattern_cc_1
+        #             if @res[1]
+        #               element_void_two
+        #             else
+        #               element_normal_two_one
+        #             end
+        #           elsif @res1.begin(0) > @res2.begin(0)
+        #             @res = @res2
+        #             # @pattern_cc = @pattern_cc_2
+        #             element_normal_two_one
+        #           end
+        #         elsif @res1 && !@res2
+        #           @res = @res1
+        #           # @pattern_cc = @pattern_cc_1
+        #           if @res[1]
+        #             element_void_two
+        #           else
+        #             element_normal_two_one
+        #           end
+        #         elsif @res2 && !@res1
+        #           @res = @res2
+        #           # @pattern_cc = @pattern_cc_2
+        #           element_normal_two_one
+        #         else
+        #           if @error_check
+        #             puts Meteor::Exception::NoSuchElementException.new(attr_name, attr_value).message
+        #           end
+        #           @elm_ = nil
+        #         end
 
         @elm_
       end
 
-      private :element_2
+      private :element_two
 
       def quote_name(name)
         @_name = Regexp.quote(name)
@@ -714,142 +670,140 @@ module Meteor
 
       private :quote_attribute
 
-      def element_pattern_2
+      def element_pattern_two
         # # @pattern_cc = String.new('') << '<([^<>"]*)\\s[^<>]*' << @_attr_name << '="' << @_attr_value << '(?:[^<>\\/]*>|((?!([^<>]*\\/>))[^<>]*>))'
         # @pattern_cc = String.new('') << '<([^<>"]*)\\s[^<>]*' << @_attr_name << '="' << @_attr_value << '"'
         @pattern_cc = "<([^<>\"]*)\\s[^<>]*#{@_attr_name}=\"#{@_attr_value}\""
       end
 
-      private :element_pattern_2
-
-=begin
-      def element_normal_2_1
-        # puts @res.captures.length
-        case @res.captures.length
-          when FOUR
-            @_name = @res[1]
-            # eleement (要素)
-            @elm_ = Element.new(@_name)
-            # attribute (属性)
-            @elm_.attributes = @res[2]
-            # content (内容)
-            @elm_.mixed_content = @res[3]
-            # document (全体)
-            @elm_.document = @res[0]
-            # pattern (内容あり要素検索用パターン)
-            # @pattern_cc = String.new('') << "<" << @_name << '\\s[^<>]*' << @_attr_name << '="'
-            # @pattern_cc << @_attr_value << '"[^<>]*>((?!(' << @_name
-            # @pattern_cc << '[^<>]*>)).)*<\\/' << @_name << '>'
-            @ pattern_cc = "<#{@_name}\\s[^<>]*#{@_attr_name}=\"#{@_attr_value}\"[^<>]*>((?!(#{@_name}[^<>]*>)).)*<\\/#{@_name}>"
-
-            @elm_.pattern = @pattern_cc
-            @elm_.normal = true
-            @elm_.parser = self
-          when FIVE,SEVEN
-            @_name = @res[3]
-            # element (要素)
-            @elm_ = Element.new(@_name)
-            # attribute (属性)
-            @elm_.attributes = @res[4]
-            # content (内容)
-            @elm_.mixed_content = @res[5]
-            # document (全体)
-            @elm_.document = @res[0]
-            # pattern (内容あり要素検索用パターン)
-            # @pattern_cc = String.new()<< "<" << @_name << '\\s[^<>]*' << @_attr_name << '="'
-            # @pattern_cc << @_attr_value << '"[^<>]*>((?!(' << @_name
-            # @pattern_cc << '[^<>]*>)).)*<\\/' << @_name << '>'
-            @pattern_cc = "<#{@_name}\\s[^<>]*#{@_attr_name}=\"#{@_attr_value}\"[^<>]*>((?!(#{@_name}[^<>]*>)).)*<\\/#{@_name}>"
-
-            @elm_.pattern = @pattern_cc
-            @elm_.normal = true
-            @elm_.parser = self
-          when THREE,SIX
-            # puts @res[1]
-            # puts @res[3]
-            # @_name = @res[1]
-            # element (要素)
-            @elm_ = Element.new(@_name)
-            # attribute (属性)
-            @elm_.attributes = @res[1].chop
-            # content (内容)
-            @elm_.mixed_content = @res[3]
-            # document (全体)
-            @elm_.document = @res[0]
-            # pattern (内容あり要素検索用パターン)
-            @elm_.pattern = @pattern_cc
-
-            @elm_.normal = true
-            @elm_.parser = self
-        end
-        @elm_
-      end
-
-      private :element_normal_2_1
-
-      def element_normal_2_2
-        # @pattern_cc_1 = String.new('') << "<" << @_name << '(\\s[^<>]*' << @_attr_name << '="'
-        # @pattern_cc_1 << @_attr_value << '(?:[^<>\\/]*>|(?:(?!([^<>]*\\/>))[^<>]*>)))'
-        @pattern_cc_1 = "<([^<>\"]*)(\\s[^<>]*#{@_attr_name}=\"#{@_attr_value}(?:[^<>\\/]*>|(?:(?!([^<>]*\\/>))[^<>]*>)))"
-
-        # search of normal element (内容あり要素検索)
-        @pattern = Meteor::Core::Util::PatternCache.get(@pattern_cc_1)
-        @sbuf = String.new('')
-
-        @cnt = 0
-
-        create_element_pattern_2(2)
-
-        @pattern_cc = @sbuf
-
-        if @sbuf.length == ZERO || @cnt != ZERO
-          return nil
-        end
-
-        @pattern = Meteor::Core::Util::PatternCache.get(@pattern_cc)
-        @res = @pattern.match(@root.document)
-      end
-
-      private :element_normal_2_2
-
-      def create_pattern_2(args_cnt)
-        @pattern_cc_1b = String.new('') << "<" << @_name << '(\\s[^<>\\/]*>|((?!([^<>]*\\/>))[^<>]*>))'
-
-        # @pattern_cc_1_1 = String.new('') << "<" << @_name << '(\\s[^<>]*' << @_attr_name << '="'
-        # @pattern_cc_1_1 << @_attr_value << '"(?:[^<>\\/]*>|(?!([^<>]*\\/>))[^<>]*>))('
-        @pattern_cc_1_1 = "<#{@_name}(\\s[^<>]*#{@_attr_name}=\"#{@_attr_value}\"(?:[^<>\\/]*>|(?!([^<>]*\\/>))[^<>]*>))("
-        @pattern_cc_1_2 = String.new('') << '.*?<' << @_name << '(\\s[^<>\\/]*>|((?!([^<>]*\\/>))[^<>]*>))'
-        @pattern_cc_2 = String.new('') << '<\\/' << @_name << '>'
-        @pattern_cc_2_1 = String.new('') << '.*?<\/' << @_name << '>'
-        @pattern_cc_2_2 = String.new('') << '.*?)<\/' << @_name << '>'
-
-        @pattern_2 = Meteor::Core::Util::PatternCache.get(@pattern_cc_2)
-        @pattern_1b = Meteor::Core::Util::PatternCache.get(@pattern_cc_1b)
-      end
-
-      def element_void_2
-        element_void_2_1('"[^<>]*\\/>')
-      end
-
-      private :element_void_2
-
-      def element_void_2_1(closer)
-        # element (要素)
-        @elm_ = Element.new(@res[1])
-        # attribute (属性)
-        @elm_.attributes = @res[2]
-        # document (全体)
-        @elm_.document = @res[0]
-        # void element search pattern (空要素検索用パターン)
-        @pattern_cc = String.new('') << "<" << @_name << '\\s[^<>]*' << @_attr_name << '="' << @_attr_value << closer
-        @elm_.pattern = @pattern_cc
-        @elm_.parser = self
-
-        @elm_
-      end
-
-      private :element_void_2_1
-=end
+      private :element_pattern_two
+
+      #       def element_normal_two_one
+      #         # puts @res.captures.length
+      #         case @res.captures.length
+      #           when FOUR
+      #             @_name = @res[1]
+      #             # eleement (要素)
+      #             @elm_ = Element.new(@_name)
+      #             # attribute (属性)
+      #             @elm_.attributes = @res[2]
+      #             # content (内容)
+      #             @elm_.mixed_content = @res[3]
+      #             # document (全体)
+      #             @elm_.document = @res[0]
+      #             # pattern (内容あり要素検索用パターン)
+      #             # @pattern_cc = String.new('') << "<" << @_name << '\\s[^<>]*' << @_attr_name << '="'
+      #             # @pattern_cc << @_attr_value << '"[^<>]*>((?!(' << @_name
+      #             # @pattern_cc << '[^<>]*>)).)*<\\/' << @_name << '>'
+      #             @ pattern_cc = "<#{@_name}\\s[^<>]*#{@_attr_name}=\"#{@_attr_value}\"[^<>]*>((?!(#{@_name}[^<>]*>)).)*<\\/#{@_name}>"
+      #
+      #             @elm_.pattern = @pattern_cc
+      #             @elm_.normal = true
+      #             @elm_.parser = self
+      #           when FIVE,SEVEN
+      #             @_name = @res[3]
+      #             # element (要素)
+      #             @elm_ = Element.new(@_name)
+      #             # attribute (属性)
+      #             @elm_.attributes = @res[4]
+      #             # content (内容)
+      #             @elm_.mixed_content = @res[5]
+      #             # document (全体)
+      #             @elm_.document = @res[0]
+      #             # pattern (内容あり要素検索用パターン)
+      #             # @pattern_cc = String.new()<< "<" << @_name << '\\s[^<>]*' << @_attr_name << '="'
+      #             # @pattern_cc << @_attr_value << '"[^<>]*>((?!(' << @_name
+      #             # @pattern_cc << '[^<>]*>)).)*<\\/' << @_name << '>'
+      #             @pattern_cc = "<#{@_name}\\s[^<>]*#{@_attr_name}=\"#{@_attr_value}\"[^<>]*>((?!(#{@_name}[^<>]*>)).)*<\\/#{@_name}>"
+      #
+      #             @elm_.pattern = @pattern_cc
+      #             @elm_.normal = true
+      #             @elm_.parser = self
+      #           when THREE,SIX
+      #             # puts @res[1]
+      #             # puts @res[3]
+      #             # @_name = @res[1]
+      #             # element (要素)
+      #             @elm_ = Element.new(@_name)
+      #             # attribute (属性)
+      #             @elm_.attributes = @res[1].chop
+      #             # content (内容)
+      #             @elm_.mixed_content = @res[3]
+      #             # document (全体)
+      #             @elm_.document = @res[0]
+      #             # pattern (内容あり要素検索用パターン)
+      #             @elm_.pattern = @pattern_cc
+      #
+      #             @elm_.normal = true
+      #             @elm_.parser = self
+      #         end
+      #         @elm_
+      #       end
+      #
+      #       private :element_normal_two_one
+      #
+      #       def element_normal_two_two
+      #         # @pattern_cc_1 = String.new('') << "<" << @_name << '(\\s[^<>]*' << @_attr_name << '="'
+      #         # @pattern_cc_1 << @_attr_value << '(?:[^<>\\/]*>|(?:(?!([^<>]*\\/>))[^<>]*>)))'
+      #         @pattern_cc_1 = "<([^<>\"]*)(\\s[^<>]*#{@_attr_name}=\"#{@_attr_value}(?:[^<>\\/]*>|(?:(?!([^<>]*\\/>))[^<>]*>)))"
+      #
+      #         # search of normal element (内容あり要素検索)
+      #         @pattern = Meteor::Core::Util::PatternCache.get(@pattern_cc_1)
+      #         @sbuf = String.new('')
+      #
+      #         @cnt = 0
+      #
+      #         create_element_pattern_two(2)
+      #
+      #         @pattern_cc = @sbuf
+      #
+      #         if @sbuf.length == ZERO || @cnt != ZERO
+      #           return nil
+      #         end
+      #
+      #         @pattern = Meteor::Core::Util::PatternCache.get(@pattern_cc)
+      #         @res = @pattern.match(@root.document)
+      #       end
+      #
+      #       private :element_normal_two_two
+      #
+      #       def create_pattern_two(args_cnt)
+      #         @pattern_cc_1b = String.new('') << "<" << @_name << '(\\s[^<>\\/]*>|((?!([^<>]*\\/>))[^<>]*>))'
+      #
+      #         # @pattern_cc_1_1 = String.new('') << "<" << @_name << '(\\s[^<>]*' << @_attr_name << '="'
+      #         # @pattern_cc_1_1 << @_attr_value << '"(?:[^<>\\/]*>|(?!([^<>]*\\/>))[^<>]*>))('
+      #         @pattern_cc_1_1 = "<#{@_name}(\\s[^<>]*#{@_attr_name}=\"#{@_attr_value}\"(?:[^<>\\/]*>|(?!([^<>]*\\/>))[^<>]*>))("
+      #         @pattern_cc_1_2 = String.new('') << '.*?<' << @_name << '(\\s[^<>\\/]*>|((?!([^<>]*\\/>))[^<>]*>))'
+      #         @pattern_cc_2 = String.new('') << '<\\/' << @_name << '>'
+      #         @pattern_cc_2_1 = String.new('') << '.*?<\/' << @_name << '>'
+      #         @pattern_cc_2_2 = String.new('') << '.*?)<\/' << @_name << '>'
+      #
+      #         @pattern_2 = Meteor::Core::Util::PatternCache.get(@pattern_cc_2)
+      #         @pattern_1b = Meteor::Core::Util::PatternCache.get(@pattern_cc_1b)
+      #       end
+      #
+      #       def element_void_two
+      #         element_void_two_one('"[^<>]*\\/>')
+      #       end
+      #
+      #       private :element_void_two
+      #
+      #       def element_void_two_one(closer)
+      #         # element (要素)
+      #         @elm_ = Element.new(@res[1])
+      #         # attribute (属性)
+      #         @elm_.attributes = @res[2]
+      #         # document (全体)
+      #         @elm_.document = @res[0]
+      #         # void element search pattern (空要素検索用パターン)
+      #         @pattern_cc = String.new('') << "<" << @_name << '\\s[^<>]*' << @_attr_name << '="' << @_attr_value << closer
+      #         @elm_.pattern = @pattern_cc
+      #         @elm_.parser = self
+      #
+      #         @elm_
+      #       end
+      #
+      #       private :element_void_two_one
 
       #
       # get element using tag name and attribute1,2(name="value") (要素のタグ名と属性1・属性2(属性名="属性値")で検索し、要素を取得する)
@@ -860,8 +814,8 @@ module Meteor
       # @param [String] attr_value2 attribute value2 (属性値2)
       # @return [Meteor::Element] element (要素)
       #
-      def element_5(name, attr_name1, attr_value1, attr_name2, attr_value2)
-        quote_element_5(name, attr_name1, attr_value1, attr_name2, attr_value2)
+      def element_five(name, attr_name1, attr_value1, attr_name2, attr_value2)
+        quote_element_five(name, attr_name1, attr_value1, attr_name2, attr_value2)
 
         @pattern_cc_1 = "<#{@_name}(\\s[^<>]*(?:#{@_attr_name1}=\"#{@_attr_value1}\"[^<>]*#{@_attr_name2}=\"#{@_attr_value2}\"|#{@_attr_name2}=\"#{@_attr_value2}\"[^<>]*#{@_attr_name1}=\"#{@_attr_value1}\")[^<>]*)\\/>|<#{@_name}(\\s[^<>]*(?:#{@_attr_name1}=\"#{@_attr_value1}\"[^<>]*#{@_attr_name2}=\"#{@_attr_value2}\"|#{@_attr_name2}=\"#{@_attr_value2}\"[^<>]*#{@_attr_name1}=\"#{@_attr_value1}\")[^<>]*)>(((?!(#{@_name}[^<>]*>)).)*)<\\/#{@_name}>"
 
@@ -869,7 +823,7 @@ module Meteor
         @res1 = @pattern.match(@root.document)
 
         if @res1 && @res1[1] || !@res1
-          @res2 = element_normal_5_2
+          @res2 = element_normal_five_two
           @pattern_cc_2 = @pattern_cc
 
           # puts @res2.captures.length
@@ -881,31 +835,29 @@ module Meteor
             @res = @res1
             # @pattern_cc = @pattern_cc_1
             if @res[1]
-              element_void_5(name)
+              element_void_five(name)
             else
-              element_normal_5_1(name)
+              element_normal_five_one(name)
             end
           elsif @res1.begin(0) > @res2.begin(0)
             @res = @res2
             # @pattern_cc = @pattern_cc_2
-            element_normal_5_1(name)
+            element_normal_five_one(name)
           end
         elsif @res1 && !@res2
           @res = @res1
           # @pattern_cc = @pattern_cc_1
           if @res[1]
-            element_void_5(name)
+            element_void_five(name)
           else
-            element_normal_5_1(name)
+            element_normal_five_one(name)
           end
         elsif @res2 && !@res1
           @res = @res2
           # @pattern_cc = @pattern_cc_2
-          element_normal_5_1(name)
+          element_normal_five_one(name)
         else
-          if @error_check
-            puts(Meteor::Exception::NoSuchElementException.new(name, attr_name, attr_value).message)
-          end
+          puts(Meteor::Exception::NoSuchElementException.new(name, attr_name, attr_value).message) if @error_check
 
           @elm_ = nil
         end
@@ -913,9 +865,9 @@ module Meteor
         @elm_
       end
 
-      private :element_5
+      private :element_five
 
-      def quote_element_5(name, attr_name1, attr_value1, attr_name2, attr_value2)
+      def quote_element_five(name, attr_name1, attr_value1, attr_name2, attr_value2)
         quote_name(name)
         @_attr_name1 = Regexp.quote(attr_name1)
         @_attr_name2 = Regexp.quote(attr_name2)
@@ -923,10 +875,9 @@ module Meteor
         @_attr_value2 = Regexp.quote(attr_value2)
       end
 
-      private :quote_element_5
-
-      def element_normal_5_1(name)
+      private :quote_element_five
 
+      def element_normal_five_one(name)
         # puts @res.captures.length
         case @res.captures.length
         when FOUR
@@ -991,14 +942,12 @@ module Meteor
         @elm_
       end
 
-      private :element_normal_5_1
+      private :element_normal_five_one
 
-      def element_normal_5_2
-        element_pattern_normal_5_2
+      def element_normal_five_two
+        element_pattern_normal_five_two
 
-        if @sbuf.length == ZERO || @cnt != ZERO
-          return nil
-        end
+        return nil if @sbuf.length == ZERO || @cnt != ZERO
 
         @pattern = Meteor::Core::Util::PatternCache.get(@pattern_cc)
         @res = @pattern.match(@root.document)
@@ -1006,17 +955,16 @@ module Meteor
         @res
       end
 
-      private :element_normal_5_2
-
-      def element_pattern_normal_5_2
+      private :element_normal_five_two
 
+      def element_pattern_normal_five_two
         # @pattern_cc_1 = String.new('') << "<" << @_name << '(\\s[^<>]*(?:' << @_attr_name1 << '="'
         # @pattern_cc_1 << @_attr_value1 << '"[^<>]*' << @_attr_name2 << '="'
         # @pattern_cc_1 << @_attr_value2 << '"|' << @_attr_name2 << '="'
         # @pattern_cc_1 << @_attr_value2 << '"[^<>]*' << @_attr_name1 << '="'
         # @pattern_cc_1 << @_attr_value1 << '")([^<>\\/]*>|((?!([^<>]*\\/>))[^<>]*>)))'
         @pattern_cc_1 = "<#{@_name}(\\s[^<>]*(?:#{@_attr_name1}=\"#{@_attr_value1}\"[^<>]*#{@_attr_name2}=\"#{@_attr_value2}\"|#{@_attr_name2}=\"#{@_attr_value2}\"[^<>]*#{@_attr_name1}=\"#{@_attr_value1}\")([^<>\\/]*>|((?!([^<>]*\\/>))[^<>]*>)))"
-        @pattern_cc_1b = String.new("") << "<" << @_name << "(\\s[^<>\\/]*>|((?!([^<>]*\\/>))[^<>]*>))"
+        @pattern_cc_1b = String.new('') << '<' << @_name << '(\\s[^<>\\/]*>|((?!([^<>]*\\/>))[^<>]*>))'
         # @pattern_cc_1b = "<#{@_name}(\\s[^<>\\/]*>|((?!([^<>]*\\/>))[^<>]*>))"
 
         # @pattern_cc_1_1 = String.new('') << "<" << @_name << '(\\s[^<>]*(?:' << @_attr_name1 << '="'
@@ -1025,10 +973,10 @@ module Meteor
         # @pattern_cc_1_1 << @_attr_value2 << '"[^<>]*' << @_attr_name1 << '="'
         # @pattern_cc_1_1 << @_attr_value1 << '")(?:[^<>\\/]*>|(?!([^<>]*\\/>))[^<>]*>))('
         @pattern_cc_1_1 = "<#{@_name}(\\s[^<>]*(?:#{@_attr_name1}=\"#{@_attr_value1}\"[^<>]*#{@_attr_name2}=\"#{@_attr_value2}\"|#{@_attr_name2}=\"#{@_attr_value2}\"[^<>]*#{@_attr_name1}=\"#{@_attr_value1}\")(?:[^<>\\/]*>|(?!([^<>]*\\/>))[^<>]*>))("
-        @pattern_cc_1_2 = String.new("") << ".*?<" << @_name << "(\\s[^<>\\/]*>|((?!([^<>]*\\/>))[^<>]*>))"
-        @pattern_cc_2 = String.new("") << "<\\/" << @_name << ">"
-        @pattern_cc_2_1 = String.new("") << ".*?<\\/" << @_name << ">"
-        @pattern_cc_2_2 = String.new("") << ".*?)<\\/" << @_name << ">"
+        @pattern_cc_1_2 = String.new('') << '.*?<' << @_name << '(\\s[^<>\\/]*>|((?!([^<>]*\\/>))[^<>]*>))'
+        @pattern_cc_2 = String.new('') << '<\\/' << @_name << '>'
+        @pattern_cc_2_1 = String.new('') << '.*?<\\/' << @_name << '>'
+        @pattern_cc_2_2 = String.new('') << '.*?)<\\/' << @_name << '>'
 
         # @pattern_cc_1_2 = ".*?<#{@_name}(\\s[^<>\\/]*>|((?!([^<>]*\\/>))[^<>]*>))"
         # @pattern_cc_2 = String.new('') << "<\\/#{@_name}>"
@@ -1038,7 +986,7 @@ module Meteor
         # search of normal element (内容あり要素検索)
         @pattern = Meteor::Core::Util::PatternCache.get(@pattern_cc_1)
 
-        @sbuf = String.new("")
+        @sbuf = String.new('')
 
         @pattern_2 = Meteor::Core::Util::PatternCache.get(@pattern_cc_2)
         @pattern_1b = Meteor::Core::Util::PatternCache.get(@pattern_cc_1b)
@@ -1048,15 +996,15 @@ module Meteor
         @pattern_cc = @sbuf
       end
 
-      private :element_pattern_normal_5_2
+      private :element_pattern_normal_five_two
 
-      def element_void_5(name)
-        element_void_5_1(name, "\")[^<>]*)\\/>")
+      def element_void_five(name)
+        element_void_five_one(name, '")[^<>]*)\\/>')
       end
 
-      private :element_void_5
+      private :element_void_five
 
-      def element_void_5_1(name, closer)
+      def element_void_five_one(name, closer)
         # element (要素)
         @elm_ = Meteor::Element.new(name)
         # attribute (属性)
@@ -1076,7 +1024,7 @@ module Meteor
         @elm_
       end
 
-      private :element_void_5_1
+      private :element_void_five_one
 
       #
       # get element using attribute1,2(name="value") (属性1・属性2(属性名="属性値")で検索し、要素を取得する)
@@ -1086,8 +1034,8 @@ module Meteor
       # @param [String]attr_value2 attribute value2 (属性値2)
       # @return [Meteor::Element] element (要素)
       #
-      def element_4(attr_name1, attr_value1, attr_name2, attr_value2)
-        quote_element_4(attr_name1, attr_value1, attr_name2, attr_value2)
+      def element_four(attr_name1, attr_value1, attr_name2, attr_value2)
+        quote_element_four(attr_name1, attr_value1, attr_name2, attr_value2)
 
         element_pattern_4
 
@@ -1095,8 +1043,8 @@ module Meteor
         @res = @pattern.match(@root.document)
 
         if @res
-          # @elm_ = element_5(@res[1], attr_name1, attr_value1,attr_name2, attr_value2)
-          element_5(@res[1], attr_name1, attr_value1, attr_name2, attr_value2)
+          # @elm_ = element_five(@res[1], attr_name1, attr_value1,attr_name2, attr_value2)
+          element_five(@res[1], attr_name1, attr_value1, attr_name2, attr_value2)
         else
           if @error_check
             puts(
@@ -1110,18 +1058,18 @@ module Meteor
         @elm_
       end
 
-      private :element_4
+      private :element_four
 
-      def quote_element_4(attr_name1, attr_value1, attr_name2, attr_value2)
+      def quote_element_four(attr_name1, attr_value1, attr_name2, attr_value2)
         @_attr_name1 = Regexp.quote(attr_name1)
         @_attr_name2 = Regexp.quote(attr_name2)
         @_attr_value1 = Regexp.quote(attr_value1)
         @_attr_value2 = Regexp.quote(attr_value2)
       end
 
-      private :quote_element_4
+      private :quote_element_four
 
-      def element_pattern_4
+      def element_pattern_four
         # @pattern_cc = String.new('') << '<([^<>"]*)\\s([^<>]*(' << @_attr_name1 << '="'
         # @pattern_cc << @_attr_value1 << '"[^<>]*' << @_attr_name2 << '="'
         # @pattern_cc << @_attr_value2 << '"|' << @_attr_name2 << '="'
@@ -1130,7 +1078,7 @@ module Meteor
         @pattern_cc = "<([^<>\"]*)\\s[^<>]*(#{@_attr_name1}=\"#{@_attr_value1}\"[^<>]*#{@_attr_name2}=\"#{@_attr_value2}\"|#{@_attr_name2}=\"#{@_attr_value2}\"[^<>]*#{@_attr_name1}=\"#{@_attr_value1}\")"
       end
 
-      private :element_pattern_4
+      private :element_pattern_four
 
       def create_element_pattern
         @position = 0
@@ -1169,109 +1117,104 @@ module Meteor
               @cnt += ONE
             end
           else
-            if @cnt == ZERO
-              break
-            end
+            break if @cnt == ZERO
 
             @res = @pattern_2.match(@root.document, @position)
 
-            if @res
-              @cnt -= ONE
-
-              if @cnt != ZERO
-                @sbuf << @pattern_cc_2_1
-              else
-                @sbuf << @pattern_cc_2_2
-                break
-              end
-
-              @position = @res.end(0)
-            else
-              break
-            end
-          end
-
-          @pattern = @pattern_1b
-        end
-      end
-
-      private :create_element_pattern
-
-=begin
-      def create_element_pattern_2(args_cnt)
-        @position = 0
-
-        while (@res = @pattern.match(@root.document, @position)) || @cnt > ZERO
-          if @res
-            if @cnt > ZERO
-              @position2 = @res.end(0)
-              @res = @pattern_2.match(@root.document, @position)
-
-              if @res
-                @position = @res.end(0)
+            break unless @res
 
-                if @position > @position2
-                  @sbuf << @pattern_cc_1_2
-                  @cnt += 1
-                  @position = @position2
-                else
-                  @cnt -= ONE
+            @cnt -= ONE
 
-                  if @cnt != ZERO
-                    @sbuf << @pattern_cc_2_1
-                  else
-                    @sbuf << @pattern_cc_2_2
-                    break
-                  end
-                end
-              else
-                @sbuf << @pattern_cc_1_2
-                @cnt += 1
-                @position = @position2
-              end
+            if @cnt != ZERO
+              @sbuf << @pattern_cc_2_1
             else
-              @position = @res.end(0)
-              @_name = @res[1]
-
-              create_pattern_2(args_cnt)
-
-              @sbuf << @pattern_cc_1_1
-              @cnt += ONE
-            end
-          else
-            if @cnt == ZERO
+              @sbuf << @pattern_cc_2_2
               break
             end
 
-            @res = @pattern_2.match(@root.document, @position)
+            @position = @res.end(0)
 
-            if @res
-              @cnt -= ONE
-
-              if @cnt != ZERO
-                @sbuf << @pattern_cc_2_1
-              else
-                @sbuf << @pattern_cc_2_2
-                break
-              end
-
-              @position = @res.end(0)
-            else
-              break
-            end
           end
 
           @pattern = @pattern_1b
         end
       end
 
-      private :create_element_pattern_2
-
-      # def create_pattern_2
-      # end
+      private :create_element_pattern
 
-      # private :create_pattern_2
-=end
+      #       def create_element_pattern_two(args_cnt)
+      #         @position = 0
+      #
+      #         while (@res = @pattern.match(@root.document, @position)) || @cnt > ZERO
+      #           if @res
+      #             if @cnt > ZERO
+      #               @position2 = @res.end(0)
+      #               @res = @pattern_2.match(@root.document, @position)
+      #
+      #               if @res
+      #                 @position = @res.end(0)
+      #
+      #                 if @position > @position2
+      #                   @sbuf << @pattern_cc_1_2
+      #                   @cnt += 1
+      #                   @position = @position2
+      #                 else
+      #                   @cnt -= ONE
+      #
+      #                   if @cnt != ZERO
+      #                     @sbuf << @pattern_cc_2_1
+      #                   else
+      #                     @sbuf << @pattern_cc_2_2
+      #                     break
+      #                   end
+      #                 end
+      #               else
+      #                 @sbuf << @pattern_cc_1_2
+      #                 @cnt += 1
+      #                 @position = @position2
+      #               end
+      #             else
+      #               @position = @res.end(0)
+      #               @_name = @res[1]
+      #
+      #               create_pattern_two(args_cnt)
+      #
+      #               @sbuf << @pattern_cc_1_1
+      #               @cnt += ONE
+      #             end
+      #           else
+      #             if @cnt == ZERO
+      #               break
+      #             end
+      #
+      #             @res = @pattern_2.match(@root.document, @position)
+      #
+      #             if @res
+      #               @cnt -= ONE
+      #
+      #               if @cnt != ZERO
+      #                 @sbuf << @pattern_cc_2_1
+      #               else
+      #                 @sbuf << @pattern_cc_2_2
+      #                 break
+      #               end
+      #
+      #               @position = @res.end(0)
+      #             else
+      #               break
+      #             end
+      #           end
+      #
+      #           @pattern = @pattern_1b
+      #         end
+      #       end
+      #
+      #       private :create_element_pattern_2
+      #
+      #       # def create_pattern_2
+      #       # end
+      #
+      #       # private :create_pattern_2
 
       # get elements (要素を取得する)
       # @overload elements(name)
@@ -1316,9 +1259,9 @@ module Meteor
       #
       def elements(elm, attrs = nil, *args)
         if !attrs
-          if elm.kind_of?(String)
+          if elm.is_a?(String)
             elements_(elm)
-          elsif elm.kind_of?(Hash)
+          elsif elm.is_a?(Hash)
             if elm.size == ONE
               elements_(elm.keys[0], elm.values[0])
             elsif elm.size == TWO
@@ -1329,7 +1272,7 @@ module Meteor
           else
             raise ArgumentError
           end
-        elsif attrs.kind_of?(Hash)
+        elsif attrs.is_a?(Hash)
           if attrs.size == ONE
             elements_(elm, attrs.keys[0], attrs.values[0])
           elsif attrs.size == TWO
@@ -1338,7 +1281,7 @@ module Meteor
             @elm_ = nil
             raise ArgumentError
           end
-        elsif attrs.kind_of?(String)
+        elsif attrs.is_a?(String)
           case args.length
           when ZERO
             elements_(elm, attrs)
@@ -1359,26 +1302,24 @@ module Meteor
       end
 
       def elements_(*args)
-        elm_arr = Array.new
+        elm_arr = []
 
         @on_search = true
 
         case args.size
         when ONE
-          @elm_ = element_1(*args)
+          @elm_ = element_one(*args)
         when TWO
-          @elm_ = element_2(*args)
+          @elm_ = element_two(*args)
         when THREE
-          @elm_ = element_3(*args)
+          @elm_ = element_three(*args)
         when FOUR
-          @elm_ = element_4(*args)
+          @elm_ = element_four(*args)
         when FIVE
-          @elm_ = element_5(*args)
+          @elm_ = element_five(*args)
         end
 
-        if !@elm_
-          return elm_arr
-        end
+        return elm_arr unless @elm_
 
         @pattern_cc = @elm_.pattern
 
@@ -1395,23 +1336,23 @@ module Meteor
           case args.size
           when ONE
             if @elm_.normal
-              element_normal_1(@elm_.name)
+              element_normal_one(@elm_.name)
             else
-              element_void_1(@elm_.name)
+              element_void_one(@elm_.name)
             end
 
           when TWO, THREE
             if @elm_.normal
-              element_normal_3_1(@elm_.name)
+              element_normal_three_one(@elm_.name)
             else
-              element_void_3(@elm_.name)
+              element_void_three(@elm_.name)
             end
 
           when FOUR, FIVE
             if @elm_.normal
-              element_normal_5_1(@elm_.name)
+              element_normal_five_one(@elm_.name)
             else
-              element_void_5(@elm_.name)
+              element_void_five(@elm_.name)
             end
           end
 
@@ -1437,76 +1378,38 @@ module Meteor
       # @return [Array<Meteor::Element>] element array (要素配列)
       #
       def find(selector)
-        open_count = selector.count("[")
+        open_count = selector.count('[')
 
         case open_count
         when ZERO
-          if selector.count("#.") == 0
-            if @res = @@pattern_find_1.match(selector)
-              elements_(@res[1])
-            else
-              nil
-            end
-          elsif selector.count("#") == 1
-            if selector[0] == "#"
-              if @res = @@pattern_find_2_1.match(selector)
-                elements_("id", @res[1])
-              else
-                nil
-              end
-            else
-              if @res = @@pattern_find_3_2.match(selector)
-                elements_(@res[1], "id", @res[2])
-              else
-                nil
-              end
+          if selector.count('#.').zero?
+            elements_(@res[1]) if (@res = @@pattern_find_1.match(selector))
+          elsif selector.count('#') == 1
+            if selector[0] == '#'
+              elements_('id', @res[1]) if (@res = @@pattern_find_2_1.match(selector))
+            elsif (@res = @@pattern_find_3_2.match(selector))
+              elements_(@res[1], 'id', @res[2])
             end
-          elsif selector.count(".") == 1
-            if selector[0] == "."
-              if @res = @@pattern_find_2_2.match(selector)
-                elements_("class", @res[1])
-              else
-                nil
-              end
-            else
-              if @res = @@pattern_find_3_3.match(selector)
-                elements_(@res[1], "class", @res[2])
-              else
-                nil
-              end
+          elsif selector.count('.') == 1
+            if selector[0] == '.'
+              elements_('class', @res[1]) if (@res = @@pattern_find_2_2.match(selector))
+            elsif (@res = @@pattern_find_3_3.match(selector))
+              elements_(@res[1], 'class', @res[2])
             end
           end
 
         when ONE
-          if selector[0] == "["
-            if @res = @@pattern_find_2_3.match(selector)
-              elements_(@res[1], @res[2])
-            else
-              nil
-            end
-          else
-            if @res = @@pattern_find_3_1.match(selector)
-              elements_(@res[1], @res[2], @res[3])
-            else
-              nil
-            end
+          if selector[0] == '['
+            elements_(@res[1], @res[2]) if (@res = @@pattern_find_2_3.match(selector))
+          elsif (@res = @@pattern_find_3_1.match(selector))
+            elements_(@res[1], @res[2], @res[3])
           end
         when 2
-          if selector[0] == "["
-            if @res = @@pattern_find_4.match(selector)
-              elements_(@res[1], @res[2], @res[3], @res[4])
-            else
-              nil
-            end
-          else
-            if @res = @@pattern_find_5.match(selector)
-              elements_(@res[1], @res[2], @res[3], @res[4], @res[5])
-            else
-              nil
-            end
+          if selector[0] == '['
+            elements_(@res[1], @res[2], @res[3], @res[4]) if (@res = @@pattern_find_4.match(selector))
+          elsif (@res = @@pattern_find_5.match(selector))
+            elements_(@res[1], @res[2], @res[3], @res[4], @res[5])
           end
-        else
-          nil
         end
       end
 
@@ -1529,29 +1432,29 @@ module Meteor
       #  @return [String] attribute value (属性値)
       #
       def attr(elm, attr, *args)
-        if attr.kind_of?(String) || attr.kind_of?(Symbol)
+        if attr.is_a?(String) || attr.is_a?(Symbol)
           case args.length
           when ZERO
             get_attr_value(elm, attr.to_s)
           when ONE
-            if args[0] != nil
+            if !args[0].nil?
               elm.document_sync = true
-              set_attribute_3(elm, attr.to_s, args[0])
+              set_attribute_three(elm, attr.to_s, args[0])
             else
               remove_attr(elm, attr.to_s)
             end
           end
-        elsif attr.kind_of?(Hash) && attr.size == 1
-          if attr.values[0] != nil
+        elsif attr.is_a?(Hash) && attr.size == 1
+          if !attr.values[0].nil?
             elm.document_sync = true
-            set_attribute_3(elm, attr.keys[0].to_s, attr.values[0])
+            set_attribute_three(elm, attr.keys[0].to_s, attr.values[0])
           else
             remove_attr(elm, attr.keys[0].to_s)
           end
           # elsif attrs.kind_of?(Hash) && attrs.size >= 1
           #  elm.document_sync = true
           #  attrs.each{|name,value|
-          #    set_attribute_3(elm,name,value)
+          #    set_attribute_three(elm,name,value)
           #  }
         else
           raise ArgumentError
@@ -1565,8 +1468,8 @@ module Meteor
       # @param [String,true,false] attr_value attribute value (属性値)
       # @return [Meteor::Element] element (要素)
       #
-      def set_attribute_3(elm, attr_name, attr_value)
-        if !elm.cx
+      def set_attribute_three(elm, attr_name, attr_value)
+        unless elm.cx
           attr_value = escape(attr_value.to_s)
           # update attributes (属性群の更新)
           edit_attrs_(elm, attr_name, attr_value)
@@ -1575,33 +1478,32 @@ module Meteor
         elm
       end
 
-      private :set_attribute_3
+      private :set_attribute_three
 
       def edit_attrs_(elm, attr_name, attr_value)
         # attribute search (属性検索)
         # @res = @pattern.match(elm.attributes)
 
         # Attribute existence check (属性の存在判定)
-        if elm.attributes.include?(String.new(" ") << attr_name << "=\"")
-          @_attr_value = attr_value
+        @_attr_value = attr_value
+        if elm.attributes.include?(String.new(' ') << attr_name << '="')
 
           # replace attribute (属性の置換)
-          @pattern = Meteor::Core::Util::PatternCache.get(String.new("") << attr_name << "=\"[^\"]*\"")
+          @pattern = Meteor::Core::Util::PatternCache.get(String.new('') << attr_name << '="[^"]*"')
           # @pattern = Meteor::Core::Util::PatternCache.get("#{attr_name}=\"[^\"]*\"")
 
-          elm.attributes.sub!(@pattern, String.new("") << attr_name << "=\"" << @_attr_value << "\"")
-          # elm.attributes.sub!(@pattern, "#{attr_name}=\"#{@_attr_value}\"")
+          elm.attributes.sub!(@pattern, String.new('') << attr_name << '="' << @_attr_value << '"')
+        # elm.attributes.sub!(@pattern, "#{attr_name}=\"#{@_attr_value}\"")
         else
           # add an attribute to attrubutes (属性文字列の最後に新規の属性を追加する)
-          @_attr_value = attr_value
 
-          if "" != elm.attributes && "" != elm.attributes.strip
-            elm.attributes = String.new("") << " " << elm.attributes.strip
-          else
-            elm.attributes = String.new("")
-          end
+          elm.attributes = if elm.attributes != '' && elm.attributes.strip != ''
+                             String.new('') << ' ' << elm.attributes.strip
+                           else
+                             String.new('')
+                           end
 
-          elm.attributes << " " << attr_name << "=\"" << @_attr_value << "\""
+          elm.attributes << ' ' << attr_name << '="' << @_attr_value << '"'
           # elm.attributes << " #{attr_name}=\"#{@_attr_value}\""
         end
       end
@@ -1622,16 +1524,14 @@ module Meteor
 
       def get_attr_value_(elm, attr_name)
         # attribute search pattern (属性検索用パターン)
-        @pattern = Meteor::Core::Util::PatternCache.get(String.new("") << attr_name << "=\"([^\"]*)\"")
+        @pattern = Meteor::Core::Util::PatternCache.get(String.new('') << attr_name << '="([^"]*)"')
         # @pattern = Meteor::Core::Util::PatternCache.get("#{attr_name}=\"([^\"]*)\"")
 
         @res = @pattern.match(elm.attributes)
 
-        if @res
-          unescape(@res[1])
-        else
-          nil
-        end
+        return unless @res
+
+        unescape(@res[1])
       end
 
       private :get_attr_value_
@@ -1649,18 +1549,17 @@ module Meteor
         when ZERO
           get_attrs(elm)
         when ONE
-          if args[0].kind_of?(Hash)
-            if args[0].size == 1
-              elm.document_sync = true
-              set_attribute_3(elm, args[0].keys[0].to_s, args[0].values[0])
-            elsif args[0].size >= 1
-              set_attrs(elm, args[0])
-            else
-              raise ArgumentError
-            end
+          raise ArgumentError unless args[0].is_a?(Hash)
+
+          if args[0].size == 1
+            elm.document_sync = true
+            set_attribute_three(elm, args[0].keys[0].to_s, args[0].values[0])
+          elsif args[0].size >= 1
+            set_attrs(elm, args[0])
           else
             raise ArgumentError
           end
+
         else
           raise ArgumentError
         end
@@ -1672,7 +1571,7 @@ module Meteor
       # @return [Hash<String,String>] attribute map (属性マップ)
       #
       def get_attrs(elm)
-        attrs = Hash.new
+        attrs = {}
 
         elm.attributes.scan(@@pattern_get_attrs_map) do |a, b|
           attrs.store(a, unescape(b))
@@ -1690,10 +1589,10 @@ module Meteor
       # @return [Meteor::Element] element (要素)
       #
       def set_attrs(elm, attr_map)
-        if !elm.cx
+        unless elm.cx
           elm.document_sync = true
           attr_map.each do |name, value|
-            set_attribute_3(elm, name.to_s, value)
+            set_attribute_three(elm, name.to_s, value)
           end
         end
 
@@ -1753,7 +1652,7 @@ module Meteor
       # @return [Meteor::Element] element (要素)
       #
       def set_attr_map(elm, attr_map)
-        if !elm.cx
+        unless elm.cx
           attr_map.map.each do |name, attr|
             if attr_map.changed(name)
               edit_attrs_(elm, name.to_s, attr.value)
@@ -1790,20 +1689,20 @@ module Meteor
         case args.length
         when ONE
           # if args[0].kind_of?(Meteor::Element)
-          get_content_1(args[0])
+          get_content_one(args[0])
           # else
           #  raise ArgumentError
           # end
         when TWO
           # if args[0].kind_of?(Meteor::Element) && args[1].kind_of?(String)
           args[0].document_sync = true
-          set_content_2(args[0], args[1].to_s)
+          set_content_two(args[0], args[1].to_s)
           # else
           #  raise ArgumentError
           # end
         when THREE
           args[0].document_sync = true
-          set_content_3(args[0], args[1].to_s, args[2])
+          set_content_three(args[0], args[1].to_s, args[2])
         else
           raise ArgumentError
         end
@@ -1816,16 +1715,14 @@ module Meteor
       # @param [true,false] entity_ref entity reference flag (エンティティ参照フラグ)
       # @return [Meteor::Element] element (要素)
       #
-      def set_content_3(elm, content, entity_ref = true)
-        if entity_ref || !elm.raw_content
-          escape_content(content, elm)
-        end
+      def set_content_three(elm, content, entity_ref = true)
+        escape_content(content, elm) if entity_ref || !elm.raw_content
 
         elm.mixed_content = content
         elm
       end
 
-      private :set_content_3
+      private :set_content_three
 
       #
       # set content of element (要素の内容をセットする)
@@ -1833,36 +1730,30 @@ module Meteor
       # @param [String] content content of element (要素の内容)
       # @return [Meteor::Element] element (要素)
       #
-      def set_content_2(elm, content)
-        # set_content_3(elm, content)
-        unless elm.raw_content
-          escape_content(content, elm)
-        end
+      def set_content_two(elm, content)
+        # set_content_three(elm, content)
+        escape_content(content, elm) unless elm.raw_content
 
         elm.mixed_content = content
         elm
       end
 
-      private :set_content_2
+      private :set_content_two
 
       #
       # get content of element (要素の内容を取得する)
       # @param [Meteor::Element] elm element (要素)
       # @return [String] content (内容)
       #
-      def get_content_1(elm)
+      def get_content_one(elm)
         if !elm.cx
-          if elm.normal
-            unescape_content(elm.mixed_content, elm)
-          else
-            nil
-          end
+          unescape_content(elm.mixed_content, elm) if elm.normal
         else
           unescape_content(elm.mixed_content, elm)
         end
       end
 
-      private :get_content_1
+      private :get_content_one
 
       #
       # remove attribute of element (要素の属性を消す)
@@ -1871,7 +1762,7 @@ module Meteor
       # @return [Meteor::Element] element (要素)
       #
       def remove_attr(elm, attr_name)
-        if !elm.cx
+        unless elm.cx
           elm.document_sync = true
           remove_attrs_(elm, attr_name.to_s)
         end
@@ -1881,10 +1772,10 @@ module Meteor
 
       def remove_attrs_(elm, attr_name)
         # attribute search pattern (属性検索用パターン)
-        @pattern = Meteor::Core::Util::PatternCache.get(String.new("") << attr_name << "=\"[^\"]*\"\\s?")
+        @pattern = Meteor::Core::Util::PatternCache.get(String.new('') << attr_name << '="[^"]*"\\s?')
         # @pattern = Meteor::Core::Util::PatternCache.get("#{attr_name}=\"[^\"]*\"\\s?")
         # replace attrubute (属性の置換)
-        elm.attributes.sub!(@pattern, "")
+        elm.attributes.sub!(@pattern, '')
       end
 
       private :remove_attrs_
@@ -1913,15 +1804,11 @@ module Meteor
       def cxtag(*args)
         case args.length
         when ONE
-          cxtag_1(args[0].to_s)
-          if @elm_
-            @element_cache.store(@elm_.object_id, @elm_)
-          end
+          cxtag_one(args[0].to_s)
+          @element_cache.store(@elm_.object_id, @elm_) if @elm_
         when TWO
-          cxtag_2(args[0].to_s, args[1].to_s)
-          if @elm_
-            @element_cache.store(@elm_.object_id, @elm_)
-          end
+          cxtag_two(args[0].to_s, args[1].to_s)
+          @element_cache.store(@elm_.object_id, @elm_) if @elm_
         else
           raise ArgumentError
         end
@@ -1933,7 +1820,7 @@ module Meteor
       # @param [String] id id attribute value (ID属性値)
       # @return [Meteor::Element] element (要素)
       #
-      def cxtag_2(name, id)
+      def cxtag_two(name, id)
         quote_name(name)
         @_id = Regexp.quote(id)
 
@@ -1971,17 +1858,17 @@ module Meteor
         @elm_
       end
 
-      private :cxtag_2
+      private :cxtag_two
 
       #
       # get cx(comment extension) tag using id attribute (ID属性(id="ID属性値")で検索し、CX(コメント拡張)タグを取得する)
       # @param [String] id id attribute value (ID属性値)
       # @return [Meteor::Element] element (要素)
       #
-      def cxtag_1(id)
+      def cxtag_one(id)
         @_id = Regexp.quote(id)
 
-        @pattern_cc = String.new("") << "<!--\\s@([^<>]*)\\s[^<>]*id=\"" << @_id << "\""
+        @pattern_cc = String.new('') << '<!--\\s@([^<>]*)\\s[^<>]*id="' << @_id << '"'
         # @pattern_cc = "<!--\\s@([^<>]*)\\s[^<>]*id=\"#{@_id}\""
 
         @pattern = Meteor::Core::Util::PatternCache.get(@pattern_cc)
@@ -1998,7 +1885,7 @@ module Meteor
         @elm_
       end
 
-      private :cxtag_1
+      private :cxtag_one
 
       #
       # replace element (要素を置換する)
@@ -2016,95 +1903,94 @@ module Meteor
 
       def reflect
         # puts @element_cache.size.to_s
-        @element_cache.values.each do |item|
-          if item.usable
-            # puts "#{item.name}:#{item.document}"
-            if !item.removed
-              if item.copy
-                @pattern = Meteor::Core::Util::PatternCache.get(item.pattern)
-                @root.document.sub!(@pattern, item.copy.parser.document_hook)
-                # item.copy.parser.element_cache.clear
-                item.copy = nil
-              else
-                edit_document_1(item)
-                # edit_pattern_(item)
-              end
+        @element_cache.each_value do |item|
+          next unless item.usable
+
+          # puts "#{item.name}:#{item.document}"
+          if !item.removed
+            if item.copy
+              @pattern = Meteor::Core::Util::PatternCache.get(item.pattern)
+              @root.document.sub!(@pattern, item.copy.parser.document_hook)
+              # item.copy.parser.element_cache.clear
+              item.copy = nil
             else
-              replace(item, "")
+              edit_document_one(item)
+              # edit_pattern_(item)
             end
-
-            item.usable = false
+          else
+            replace(item, '')
           end
+
+          item.usable = false
         end
       end
 
       protected :reflect
 
-      def edit_document_1(elm)
-        edit_document_2(elm, "/>")
+      def edit_document_one(elm)
+        edit_document_two(elm, '/>')
       end
 
-      private :edit_document_1
+      private :edit_document_one
 
-      def edit_document_2(elm, closer)
+      def edit_document_two(elm, _closer)
         # replace tag (タグ置換)
         @pattern = Meteor::Core::Util::PatternCache.get(elm.pattern)
         @root.document.sub!(@pattern, elm.document)
       end
 
-      private :edit_document_2
+      private :edit_document_two
 
       #
       # reflect (反映する)
       #
       def flash
-        if self.element_hook
-          if self.element_hook.origin.mono
-            if self.element_hook.origin.cx
+        if element_hook
+          if element_hook.origin.mono
+            if element_hook.origin.cx
               # @root.hookDocument << '<!-- @' << @root.element.name << ' '
               # @root.hookDocument << @root.element.attributes << '-->'
               # @root.hookDocument << @root.element.mixed_content << '<!-- /@'
               # @root.hookDocument << @root.element.name << ' -->'
-              self.document_hook <<
-                "<!-- @#{self.element_hook.name} #{self.element_hook.attributes}-->#{self.element_hook.mixed_content}<!-- /@#{self.element_hook.name} -->"
+              document_hook <<
+                "<!-- @#{element_hook.name} #{element_hook.attributes}-->#{element_hook.mixed_content}<!-- /@#{element_hook.name} -->"
 
               # self.document_hook << @root.newline << "<!-- @#{self.element_hook.name} #{self.element_hook.attributes}-->#{self.element_hook.mixed_content}<!-- /@#{self.element_hook.name} -->"
             else
               # @root.hookDocument << "<" << @root.element.name
               # @root.hookDocument << @root.element.attributes << '>' << @root.element.mixed_content
               # @root.hookDocument << '</' << @root.element.name << '>'
-              self.document_hook <<
-                "<#{self.element_hook.name}#{self.element_hook.attributes}>#{self.element_hook.mixed_content}</#{self.element_hook.name}>"
+              document_hook <<
+                "<#{element_hook.name}#{element_hook.attributes}>#{element_hook.mixed_content}</#{element_hook.name}>"
 
               # self.document_hook << @root.newline << "<#{self.element_hook.name}#{self.element_hook.attributes}>#{self.element_hook.mixed_content}</#{self.element_hook.name}>"
             end
 
-            self.element_hook = self.element_hook.origin.clone(self)
           else
             reflect
-            @_attributes = self.element_hook.attributes
+            @_attributes = element_hook.attributes
 
-            if self.element_hook.origin.cx
+            if element_hook.origin.cx
               # @root.hookDocument << '<!-- @' << @root.element.name << ' '
               # @root.hookDocument << @_attributes << '-->'
               # @root.hookDocument << @root.document << '<!-- /@'
               # @root.hookDocument << @root.element.name << ' -->'
-              self.document_hook <<
-                "<!-- @#{self.element_hook.name} #{@_attributes}-->#{@root.document}<!-- /@#{self.element_hook.name} -->"
+              document_hook <<
+                "<!-- @#{element_hook.name} #{@_attributes}-->#{@root.document}<!-- /@#{element_hook.name} -->"
 
               # self.document_hook << @root.newline << "<!-- @#{self.element_hook.name} #{@_attributes}-->#{@root.document}<!-- /@#{self.element_hook.name} -->"
             else
               # @root.hookDocument << "<" << @root.element.name
               # @root.hookDocument << @_attributes << '>' << @root.document
               # @root.hookDocument << '</' << @root.element.name << '>'
-              self.document_hook <<
-                "<#{self.element_hook.name}#{@_attributes}>#{@root.document}</#{self.element_hook.name}>"
+              document_hook <<
+                "<#{element_hook.name}#{@_attributes}>#{@root.document}</#{element_hook.name}>"
 
               # self.document_hook << @root.newline << "<#{self.element_hook.name}#{@_attributes}>#{@root.document}</#{self.element_hook.name}>"
             end
 
-            self.element_hook = self.element_hook.origin.clone(self)
           end
+          self.element_hook = element_hook.origin.clone(self)
         else
           reflect
           @element_cache.clear
@@ -2115,10 +2001,10 @@ module Meteor
       def clean
         # replace CX start tag (CX開始タグ置換)
         @pattern = @@pattern_clean1
-        @root.document.gsub!(@pattern, "")
+        @root.document.gsub!(@pattern, '')
         # rplace CX end tag (CX終了タグ置換)
         @pattern = @@pattern_clean2
-        @root.document.gsub!(@pattern, "")
+        @root.document.gsub!(@pattern, '')
         # @root.document << "<!-- Powered by Meteor (C)Yasumasa Ashida -->"
       end
 
@@ -2131,24 +2017,24 @@ module Meteor
       # @return [Meteor::Element] element (要素)
       #
       def shadow(elm)
-        if elm.normal
-          # case of normal element (内容あり要素の場合)
-          set_mono_info(elm)
+        return unless elm.normal
 
-          pif2 = self.class.new(self)
+        # case of normal element (内容あり要素の場合)
+        set_mono_info(elm)
 
-          @elm_ = elm.clone(pif2)
+        pif2 = self.class.new(self)
 
-          if !elm.mono
-            pif2.root_element.document = String.new(elm.mixed_content)
-          else
-            pif2.root_element.document = String.new(elm.document)
-          end
+        @elm_ = elm.clone(pif2)
 
-          pif2.root_element.newline = elm.parser.root_element.newline
+        pif2.root_element.document = if !elm.mono
+                                       String.new(elm.mixed_content)
+                                     else
+                                       String.new(elm.document)
+                                     end
 
-          @elm_
-        end
+        pif2.root_element.newline = elm.parser.root_element.newline
+
+        @elm_
       end
 
       # private :shadow
@@ -2156,24 +2042,19 @@ module Meteor
       def set_mono_info(elm)
         @res = @@pattern_set_mono1.match(elm.mixed_content)
 
-        if @res
-          elm.mono = true
-        end
+        elm.mono = true if @res
       end
 
       private :set_mono_info
 
       def is_match(regex, str)
-        if regex.kind_of?(Regexp)
+        case regex
+        when Regexp
           is_match_r(regex, str)
-        elsif regex.kind_of?(Array)
+        when Array
           is_match_a(regex, str)
-        elsif regex.kind_of?(String)
-          if regex == str.downcase
-            true
-          else
-            false
-          end
+        when String
+          regex == str.downcase
         else
           raise ArgumentError
         end
@@ -2214,16 +2095,12 @@ module Meteor
 
       def escape(content)
         # replace special character (特殊文字の置換)
-        content = content.gsub(@@pattern_escape, TABLE_FOR_ESCAPE_)
-
-        content
+        content.gsub(@@pattern_escape, TABLE_FOR_ESCAPE_)
       end
 
-      def escape_content(content, elm)
+      def escape_content(content, _elm)
         # replace special character (特殊文字の置換)
-        content = content.gsub(@@pattern_escape_content, TABLE_FOR_ESCAPE_CONTENT_)
-
-        content
+        content.gsub(@@pattern_escape_content, TABLE_FOR_ESCAPE_CONTENT_)
       end
 
       private :escape
@@ -2237,19 +2114,19 @@ module Meteor
         # 「 」<-「&nbsp;」
         # 「&」<-「&amp;」
         content.gsub(@@pattern_unescape) do
-          case $1
-          when "amp"
-            "&"
-          when "quot"
-            "\""
-          when "apos"
+          case ::Regexp.last_match(1)
+          when 'amp'
+            '&'
+          when 'quot'
+            '"'
+          when 'apos'
             "'"
-          when "gt"
-            ">"
-          when "lt"
-            "<"
-          when "nbsp"
-            " "
+          when 'gt'
+            '>'
+          when 'lt'
+            '<'
+          when 'nbsp'
+            ' '
           end
         end
 
@@ -2259,15 +2136,15 @@ module Meteor
       private :unescape
 
       def br_to_newline(content)
-        if (elm.cx || !is_match(@@match_tag_2, elm.name)) && content.include?(BR)
-          # 「<br>」->「¥r?¥n」
-          content.gsub!(@@pattern_br_2, @root.newline)
-        end
+        return unless (elm.cx || !is_match(@@match_tag_2, elm.name)) && content.include?(BR)
+
+        # 「<br>」->「¥r?¥n」
+        content.gsub!(@@pattern_br_2, @root.newline)
       end
 
       private :br_to_newline
 
-      def unescape_content(content, elm)
+      def unescape_content(content, _elm)
         content_ = unescape(content)
 
         br_to_newline(content_)