RubyGems - xrt - Versions diffs - 0.0.1 - Mend

xrt 0.0.1

Files changed (28) hide show

checksums.yaml ADDED Viewed

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4f297398d1b9757376b533d456353e069ad6c852
+  data.tar.gz: a953d05e896c259e4c46fa2414cff70d66407969
+SHA512:
+  metadata.gz: d0ed3a59d292aa21d82f91d7c6277a19793d0f0fd8f9c7c1c7008a557f7408628d7e6355b922d0e5ff2fb4cd4642039ee2032aa8ffd77e88e20ca99f17f738fa
+  data.tar.gz: 4a39005f378374d91efcda18bf016744873bb07778c5e1579b90f00e06516796e40b38a4484b9c71322c189653f0ae5d7dfce52dcc1710c0bdb0bc1cc9f80c52

data/.gitignore ADDED Viewed

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml ADDED Viewed

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2
+  - 2.0

data/Gemfile ADDED Viewed

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+# Specify your gem's dependencies in xrt.gemspec
+gemspec

data/LICENSE.txt ADDED Viewed

@@ -0,0 +1,22 @@
+Copyright (c) 2016 hitode909
+MIT License
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md ADDED Viewed

@@ -0,0 +1,85 @@
+[![Build Status](https://travis-ci.org/hitode909/xrt.svg?branch=master)](https://travis-ci.org/hitode909/xrt)
+# XRT
+Refactoring Tool for [Text::Xslate](https://metacpan.org/pod/Text::Xslate).
+Currently aim to refactor [Syntax::TTerse](https://metacpan.org/pod/Text::Xslate::Syntax::TTerse) templates.
+## Installation
+```
+$ gem install xrt
+```
+## Commands
+`XRT` provides `xrt` command.
+### Dump
+`xrt dump` command annotates the template with nested levels of control statements.
+```
+$ xrt dump TARGET_TEMPLATE
+```
+#### Example
+`FOR` locates on nested level 1, and inner `IF` locates on nested level is 2.
+Valid templates must end with nested level is 0.
+```
+% xrt dump templates/sample.html
+Dumping templates/sample.html
+<html>
+  <body>
+    0[% FOR item IN items %]1
+      1[% IF item.title %]2
+        <h1>2[% title %]2</h1>
+      2[% END %]1
+    1[% END %]0
+  </body>
+</html>
+0
+```
+### Extract
+`xrt extract` extracts the specified block from target template to another new template.
+```
+$ xrt extract TARGET_TEMPLATE TARGET_BLOCK TEMPLATES_DIRECTORY NEW_TEMPLATE_NAME
+```
+#### Example
+When you want to extract `FOR` block to new template `templates/_items.tt`,
+- `TARGET_TEMPLATE` is the path of original template.
+- Set `TARGET_BLOCK` like `[% FOR item IN items %]`, `[% FOR item IN` or `[% FOR`. This must match with a beginning of only one block.
+- `TEMPLATES_DIRECTORY` is the directory which the template is located. Usually it may be `templates/` or `views/`.
+- `NEW_TEMPLATE_NAME` is the new template. This parameter is used to generate new `[% INCLUDE %]` directive. New template will stored in `TEMPLATES_DIRECTORY`.
+```
+% xrt extract templates/sample.html '[% FOR item IN items %]' templates/ _items.tt
+```
+The result is below.
+```
+# tempaltes/sample.html
+<html>
+  <body>
+    [% INCLUDE "_items.tt" %]
+  </body>
+</html>
+```
+```
+# templates/_items.tt
+[% FOR item IN items %]
+  [% IF item.title %]
+    <h1>[% title %]</h1>
+  [% END %]
+[% END %]
+```

data/Rakefile ADDED Viewed

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+task :default => :test
+desc "Run tests"
+task :test do
+  ruby("test/run-test.rb")
+end

data/bin/xrt ADDED Viewed

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+lib_dir = File.join(base_dir, "lib")
+$LOAD_PATH.unshift(lib_dir)
+require 'xrt/cli'
+cli = XRT::CLI.new
+cli.execute ARGV

data/lib/xrt/cli.rb ADDED Viewed

@@ -0,0 +1,22 @@
+require 'xrt/commands'
+module XRT
+  class CLI
+    def execute(args)
+      command_name = args.shift
+      case command_name
+      when 'dump'
+        success = XRT::Command::Dump.new.execute(args)
+        exit success ? 0 : 1
+      when 'extract'
+        success = XRT::Command::Extract.new.execute(*args)
+        exit success ? 0 : 1
+      else
+        warn "command not found"
+        exit 1
+      end
+    end
+  end
+end

data/lib/xrt/commands.rb ADDED Viewed

@@ -0,0 +1,70 @@
+require 'pathname'
+require 'xrt/depth_checker'
+module XRT
+  module Command
+    class Dump
+      def execute(files)
+        files.each{|file|
+          dump_file file
+        }
+      end
+      def dump_file target_file
+        warn "Dumping #{target_file}"
+        checker = XRT::DepthChecker.new
+        parsed, annotated_source = checker.check open(target_file).read
+        puts annotated_source
+        unless parsed
+          raise "Failed to parser #{target_file} (#{index}/#{target_files.length})"
+        end
+      end
+    end
+    class Extract
+      # xrt extract templates/blogs/index.html '[% IF pager' 'templates/' 'blogs/_pager.tt'
+      def execute(from_file, target_block, templates_directory, to_file_name)
+        from_source = open(from_file).read
+        parser = XRT::Parser.new(from_source)
+        from_doc = parser.document
+        found_blocks = from_doc.find_blocks.select{|block|
+          block.content.index(target_block) == 0
+        }
+        if found_blocks.length == 0
+          raise "target_block not found"
+        end
+        if found_blocks.length > 1
+          raise "ambiguous target_block"
+        end
+        found_block = found_blocks.first
+        replace_to_node = XRT::Parser.new(%Q{[% INCLUDE "#{to_file_name}" %]}).document
+        from_doc.replace_child(replace_to_node, found_block)
+        content_to_overwrite = from_doc.content
+        content_for_new_file = found_block.auto_indent
+        open(from_file, 'w'){|f|
+          f.write content_to_overwrite
+        }
+        new_file = Pathname(templates_directory).join(to_file_name)
+        if new_file.exist?
+          raise 'TO_FILE_NAME exists.'
+        end
+        open(new_file, 'w'){|f|
+          f.puts content_for_new_file
+        }
+        true
+      end
+    end
+  end
+end

data/lib/xrt/depth_checker.rb ADDED Viewed

@@ -0,0 +1,51 @@
+require 'xrt/parser'
+require 'xrt/syntax'
+module XRT
+  class DepthChecker
+    def check source
+      annotated_source = ''
+      parser = XRT::Parser.new(source)
+      syntax = XRT::Syntax.new
+      current_level = 0
+      parser.tokens.each{|statement|
+        diff = syntax.block_level statement
+        current_level += diff
+        annotated_source += statement
+        color = 44 + diff
+        if STDOUT.tty?
+          annotated_source += "\e[#{color}m#{current_level}\e[0m"
+        else
+          annotated_source += current_level.to_s
+        end
+      }
+      if current_level == 0
+        return true, annotated_source
+      else
+        return false, annotated_source
+      end
+    end
+    def max_depth source
+      parser = XRT::Parser.new(source)
+      syntax = XRT::Syntax.new
+      max_level = 0
+      current_level = 0
+      parser.tokens.each{|statement|
+        diff = syntax.block_level statement
+        current_level += diff
+        max_level = [ current_level, max_level].max
+      }
+      if current_level != 0
+        raise 'failed to parse'
+      end
+      max_level
+    end
+  end
+end

data/lib/xrt/parser.rb ADDED Viewed

@@ -0,0 +1,79 @@
+require 'xrt/statement'
+module XRT
+  class Parser
+    def initialize(source='')
+      @source = source
+    end
+    def document
+      doc = XRT::Statement::Document.new
+      tokenized = self.tokens
+      parse_contents(tokenized, doc)
+      doc
+    end
+    def parse_contents(tokenized, node)
+      while tokenized.length > 0
+        statement = XRT::Statement::Factory.new_from_content(tokenized.shift)
+        case statement
+        when XRT::Statement::Block
+          parse_contents(tokenized, statement)
+          node << statement
+        when XRT::Statement::End
+          node << statement
+          break
+        when XRT::Statement::Text
+          node << statement
+        when XRT::Statement::Directive
+          node << statement
+        end
+      end
+      node
+    end
+    def tokens
+      reading = @source.dup
+      result = []
+      while reading.length > 0
+        got = read_directive(reading) || read_text(reading)
+        unless got
+          raise "failed to parse #{@source}"
+        end
+        result << got
+      end
+      result
+    end
+    def read_directive source
+      return nil unless source[0...2] == '[%'
+      buffer = ''
+      while source[0...2] != '%]'
+        buffer << source.slice!(0)
+      end
+      buffer << source.slice!(0, 2)
+      buffer
+    end
+    def read_text source
+      return nil if source[0...2] == '[%'
+      buffer = ''
+      while true
+        return buffer if source[0...2] == '[%'
+        break if source.length < 2
+        buffer << source.slice!(0)
+      end
+      buffer << source.slice!(0, source.length)
+      buffer
+    end
+  end
+end

data/lib/xrt/statement.rb ADDED Viewed

@@ -0,0 +1,145 @@
+require 'xrt/syntax'
+module XRT
+  class Statement
+    def initialize(content)
+      @content = content
+    end
+    def content
+      @content
+    end
+    def == other
+      self.class == other.class && self.content == other.content
+    end
+    def inspect
+      "<#{self.class}:#{self.content}>"
+    end
+    def children
+      []
+    end
+    def replace_child(new_child, old_child)
+      children.each_with_index{|child, index|
+        if child.equal? old_child
+          children[index] = new_child
+          return old_child
+        elsif child.replace_child(new_child, old_child)
+          return old_child
+        end
+      }
+      nil
+    end
+    def depth(target)
+      children.each{|child|
+        return 0 if child.equal? target
+        d = child.depth(target)
+        if d
+          return d + 1
+        end
+      }
+      nil
+    end
+    def find_blocks
+      children.select{|child|
+        child.kind_of? XRT::Statement::Block
+      }.concat(children.map{|child| child.find_blocks }.flatten)
+    end
+    def auto_indent
+      lines = content.split(/\n/)[1..-1]
+      whitespaces = lines.map{|line| line.scan(/^\s+/).first }.compact
+      indent = whitespaces.sort_by{|whitespace| whitespace.length }.first
+      content.gsub(/^#{indent}/, '')
+    end
+  end
+  class Statement
+    module Factory
+      def self.new_from_content content
+        syntax = XRT::Syntax.new
+        block_level = syntax.block_level content
+        if block_level == 1
+          XRT::Statement::Block.new content
+        elsif block_level == -1
+          XRT::Statement::End.new content
+        elsif syntax.block? content
+          XRT::Statement::Directive.new content
+        else
+          XRT::Statement::Text.new content
+        end
+      end
+    end
+    class Document < Statement
+      def initialize
+        @children = []
+      end
+      def << statement
+        @children << statement
+      end
+      def children
+        @children
+      end
+      def content
+        children.map{|c| c.content }.join
+      end
+      def == other
+        self.content == other.content && self.children.zip(other.children).all{|a, b| p [a, b]; a == b }
+      end
+      def inspect
+        "<#{self.class}:#{self.children}>"
+      end
+    end
+    class Text < Statement
+    end
+    class Directive < Statement
+    end
+    class End < Directive
+    end
+    class Block < Directive
+      def initialize(content)
+        super
+        @children = []
+      end
+      def closed?
+        children.last.kind_of? End
+      end
+      def << statement
+        raise 'trying to push_child to closed block' if closed?
+        @children << statement
+      end
+      def children
+        @children
+      end
+      def content
+        @content + children.map{|c| c.content }.join
+      end
+      def inspect
+        "<#{self.class}:#{@content},#{self.children}>"
+      end
+    end
+  end
+end

data/lib/xrt/syntax.rb ADDED Viewed

@@ -0,0 +1,40 @@
+module XRT
+  class Syntax
+    def block? statement
+      statement =~ /\A\[%.+%\]\Z/m
+    end
+    def beginning_block? statement
+      without_comment = remove_comment statement
+      without_comment =~ beginning_block_regexp
+    end
+    def end_block? statement
+      return unless block? statement
+      without_comment = remove_comment statement
+      without_comment =~ end_block_regexp
+    end
+    def beginning_block_regexp
+      keywords = %w(IF UNLESS FOR FOREACH WHILE SWITCH MACRO BLOCK WRAPPER FILTER)
+      /\[%.?\s*\b(#{keywords.join('|')})\b/i
+    end
+    def end_block_regexp
+      /\bEND\b/i
+    end
+    def remove_comment(statement)
+      statement.gsub(/\s*#.*$/, '')
+    end
+    def block_level(statement)
+      stripped = statement.strip
+      return 0 unless block? stripped
+      level = 0
+      level += 1 if beginning_block? stripped
+      level -= 1 if end_block? stripped
+      level
+    end
+  end
+end

data/lib/xrt/version.rb ADDED Viewed

@@ -0,0 +1,3 @@
+module Xrt
+  VERSION = "0.0.1"
+end

data/lib/xrt.rb ADDED Viewed

@@ -0,0 +1,5 @@
+require "xrt/version"
+module Xrt
+  # Your code goes here...
+end

data/sketch/dump_blocks.rb ADDED Viewed

@@ -0,0 +1,22 @@
+base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+lib_dir = File.join(base_dir, "lib")
+$LOAD_PATH.unshift(lib_dir)
+require 'xrt/parser'
+require 'pp'
+target_files = ARGV
+target_files.each_with_index{|target_file, index|
+  warn "Dumping #{target_file}"
+  source = open(target_file).read
+  parser = XRT::Parser.new(source)
+  doc = parser.document
+  doc.find_blocks.each{|block|
+    p "depth: #{doc.depth(block)}"
+    puts block.content
+  }
+}
+exit 0

data/sketch/dump_max_depth.rb ADDED Viewed

@@ -0,0 +1,16 @@
+base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+lib_dir = File.join(base_dir, "lib")
+$LOAD_PATH.unshift(lib_dir)
+require 'xrt/depth_checker'
+target_files = ARGV
+checker = XRT::DepthChecker.new
+target_files.each{|target_file|
+  level = checker.max_depth open(target_file).read
+  puts [level, target_file].join("\t")
+}
+exit 0

data/sketch/dump_tree.rb ADDED Viewed

@@ -0,0 +1,17 @@
+base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+lib_dir = File.join(base_dir, "lib")
+$LOAD_PATH.unshift(lib_dir)
+require 'xrt/parser'
+require 'pp'
+target_files = ARGV
+target_files.each_with_index{|target_file, index|
+  warn "Dumping #{target_file}"
+  source = open(target_file).read
+  parser = XRT::Parser.new(source)
+  pp parser.document
+}
+exit 0

data/sketch/find_block.rb ADDED Viewed

@@ -0,0 +1,24 @@
+base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+lib_dir = File.join(base_dir, "lib")
+$LOAD_PATH.unshift(lib_dir)
+require 'xrt/parser'
+target_file, target_block = *ARGV
+warn "target_file: #{target_file}"
+warn "target_block: #{target_block}"
+source = open(target_file).read
+parser = XRT::Parser.new(source)
+doc = parser.document
+found = doc.find_blocks.select{|block|
+  block.content.index(target_block) == 0
+}.first
+if found
+  puts found.auto_indent
+else
+  warn 'not found'
+  exit 1
+end

data/sketch/replace_block.rb ADDED Viewed

@@ -0,0 +1,31 @@
+base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+lib_dir = File.join(base_dir, "lib")
+$LOAD_PATH.unshift(lib_dir)
+require 'xrt/parser'
+target_file, target_block, replace_to = *ARGV
+warn "target_file: #{target_file}"
+warn "target_block: #{target_block}"
+warn "replace_to: #{replace_to}"
+source = open(target_file).read
+parser = XRT::Parser.new(source)
+doc = parser.document
+found = doc.find_blocks.select{|block|
+  block.content.index(target_block) == 0
+}.first
+if found
+  puts found.content
+else
+  warn 'not found'
+  exit 1
+end
+replace_to_node = XRT::Parser.new(replace_to).document
+doc.replace_child(replace_to_node, found)
+puts doc.content

data/test/run-test.rb ADDED Viewed

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+$VERBOSE = true
+base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+lib_dir = File.join(base_dir, "lib")
+test_dir = File.join(base_dir, "test")
+require "test-unit"
+$LOAD_PATH.unshift(lib_dir)
+$LOAD_PATH.unshift(test_dir)
+ENV["TEST_UNIT_MAX_DIFF_TARGET_STRING_SIZE"] ||= "5000"
+exit Test::Unit::AutoRunner.run(true, test_dir)

data/test/test-depth_checker.rb ADDED Viewed

@@ -0,0 +1,25 @@
+require 'test/unit'
+require 'xrt/depth_checker'
+class TestDepthChecker < Test::Unit::TestCase
+  def setup
+    @checker = XRT::DepthChecker.new
+  end
+  def test_check
+    assert_equal true, @checker.check(%q{[% IF a %]1[% END %]})[0]
+    assert_equal true, @checker.check(%q{hi})[0]
+    assert_equal false, @checker.check(%q{[% IF a %]})[0]
+    assert_equal true, @checker.check(%q{[% IF a %]1[% END %]})[1].kind_of?(String)
+    assert_equal true, @checker.check(%q{[% IF a %]})[1].kind_of?(String)
+  end
+  def test_max_depth
+    assert_equal 0, @checker.max_depth(%q{foo})
+    assert_equal 0, @checker.max_depth(%q{[% foo %]})
+    assert_equal 1, @checker.max_depth(%q{[% IF a %]1[% END %]})
+    assert_raises { @checker.max_depth(%q{[% IF a %]}) }
+  end
+end

data/test/test-parser.rb ADDED Viewed

@@ -0,0 +1,89 @@
+require 'test/unit'
+require 'xrt/parser'
+class TestParser < Test::Unit::TestCase
+  def setup
+    @parser = XRT::Parser.new
+  end
+  def test_document_empty
+    parser = XRT::Parser.new('')
+    doc = parser.document
+    assert doc.kind_of? XRT::Statement::Document
+    assert_equal [], doc.children
+  end
+  def test_document_text_directive
+    parser = XRT::Parser.new('1[% 2 %]3')
+    doc = parser.document
+    assert doc.kind_of? XRT::Statement::Document
+    assert_equal [
+      XRT::Statement::Text.new('1'),
+      XRT::Statement::Directive.new('[% 2 %]'),
+      XRT::Statement::Text.new('3'),
+    ], doc.children
+  end
+  def test_document_block
+    parser = XRT::Parser.new('[% IF a %]1[% END %]')
+    doc = parser.document
+    assert doc.kind_of? XRT::Statement::Document
+    if_block = XRT::Statement::Block.new('[% IF a %]')
+    if_block << XRT::Statement::Text.new('1')
+    if_block << XRT::Statement::Text.new('[% END %]')
+    assert_equal [
+      if_block
+    ], doc.children
+  end
+    def test_document_nested_block
+      parser = XRT::Parser.new('[% IF a %][% IF b %]1[% END %][% END %]')
+      doc = parser.document
+      assert doc.kind_of? XRT::Statement::Document
+      if_block1 = XRT::Statement::Block.new('[% IF a %]')
+      if_block2 = XRT::Statement::Block.new('[% IF b %]')
+      if_block2 << XRT::Statement::Text.new('1')
+      if_block2 << XRT::Statement::Text.new('[% END %]')
+      if_block1 << if_block2
+      if_block1 << XRT::Statement::Text.new('[% END %]')
+      assert_equal [
+        if_block1
+      ], doc.children
+    end
+  def test_read_directive
+    assert_equal '[% %]', @parser.read_directive('[% %]')
+    assert_equal '[% [ ] %]', @parser.read_directive('[% [ ] %]')
+    assert_nil @parser.read_directive('hi')
+  end
+  def test_read_text
+    assert_equal 'hi', @parser.read_text('hi')
+    assert_equal 'hi[', @parser.read_text('hi[')
+    assert_equal 'hi', @parser.read_text('hi[%')
+    assert_nil @parser.read_text('[% %]')
+  end
+  def test_tokens
+    test_cases = [
+      ['<html>', ['<html>']],
+      ['a [% b %] c', ['a ', '[% b %]', ' c']],
+      ['[% a %] [% b %] [% c %]', ['[% a %]', ' ', '[% b %]', ' ', '[% c %]']],
+      ['[% FOR k IN [1, 2, 3] %]', ['[% FOR k IN [1, 2, 3] %]']],
+      [
+        %q([% WRAPPER "wrapper.tt" WITH args = [1,2,3] %]<div></div>[% END %]),
+        [
+          %q([% WRAPPER "wrapper.tt" WITH args = [1,2,3] %]),
+          %q(<div></div>),
+          %q([% END %]),
+        ]
+      ],
+    ]
+    test_cases.each{|test_case|
+      input, expected = *test_case
+      parser = XRT::Parser.new(input)
+      assert_equal expected, parser.tokens
+    }
+  end
+end

data/test/test-statement.rb ADDED Viewed

@@ -0,0 +1,157 @@
+require 'test/unit'
+require 'xrt/statement'
+class TestStatementFactory < Test::Unit::TestCase
+  def test_new_from_string
+    assert XRT::Statement::Factory.new_from_content('hi').kind_of? XRT::Statement::Text
+    assert XRT::Statement::Factory.new_from_content('[% foo %]').kind_of? XRT::Statement::Directive
+    assert XRT::Statement::Factory.new_from_content('[% IF 1 %]').kind_of? XRT::Statement::Block
+    assert XRT::Statement::Factory.new_from_content('[% foo IF 1 %]').kind_of? XRT::Statement::Directive
+  end
+end
+class TestStatement < Test::Unit::TestCase
+  def test_text
+    text = XRT::Statement::Text.new('hi')
+    assert text.kind_of? XRT::Statement
+    assert_equal text.content, 'hi'
+    assert_equal text.children, []
+  end
+  def test_text_auto_indent
+    text = XRT::Statement::Text.new(<<'HTML')
+<html>
+    <body>
+    </body>
+  </html>
+HTML
+    assert_equal text.auto_indent, <<'HTML'
+<html>
+  <body>
+  </body>
+</html>
+HTML
+  end
+  def test_directive
+    text = XRT::Statement::End.new('[% foo() %]')
+    assert text.kind_of? XRT::Statement
+    assert_equal text.content, '[% foo() %]'
+    assert_equal text.children, []
+  end
+  def test_end
+    text = XRT::Statement::End.new('[% END %]')
+    assert text.kind_of? XRT::Statement
+    assert_equal text.content, '[% END %]'
+    assert_equal text.children, []
+  end
+  def test_block
+    text = XRT::Statement::Block.new('[% IF 1 %]')
+    assert text.kind_of? XRT::Statement
+    assert_equal text.content, '[% IF 1 %]'
+    assert_equal text.children, []
+  end
+  def test_document
+    document = XRT::Statement::Document.new
+    s1 = XRT::Statement::Text.new('ok')
+    s2 = XRT::Statement::Directive.new('[% foo %]')
+    document << s1
+    document << s2
+    assert_equal document.children, [s1, s2]
+    assert_equal document.content, %q{ok[% foo %]}
+  end
+  def test_replace_child
+    document = XRT::Statement::Document.new
+    s1 = XRT::Statement::Text.new('1')
+    s2 = XRT::Statement::Text.new('2')
+    s3 = XRT::Statement::Text.new('3')
+    document << s1
+    assert_nil document.replace_child(s2, s3),'when not found'
+    assert_equal '1', document.content, 'not changed'
+    replaced = document.replace_child(s2, s1)
+    assert_same replaced, s1
+    assert_equal '2', document.content, 'replaced'
+  end
+  def test_replace_child_for_descendant
+    document = XRT::Statement::Document.new
+    if_block = XRT::Statement::Block.new('[% IF a %]')
+    if_block_inner_text = XRT::Statement::Text.new('1')
+    new_if_block_inner_text = XRT::Statement::Text.new('2')
+    if_block << if_block_inner_text
+    if_block << XRT::Statement::Text.new('[% END %]')
+    document << if_block
+    assert document.replace_child(new_if_block_inner_text, if_block_inner_text)
+    assert_equal '[% IF a %]2[% END %]', document.content
+  end
+  def test_depth
+    document = XRT::Statement::Document.new
+    s1 = XRT::Statement::Text.new('1')
+    if_block = XRT::Statement::Block.new('[% IF a %]')
+    if_block_inner_text = XRT::Statement::Text.new('1')
+    if_block << if_block_inner_text
+    if_block << XRT::Statement::Text.new('[% END %]')
+    not_child = XRT::Statement::Text.new('not_child')
+    document << s1
+    document << if_block
+    assert_equal 0, document.depth(s1)
+    assert_equal 0, document.depth(if_block)
+    assert_equal 1, document.depth(if_block_inner_text)
+    assert_equal nil, document.depth(not_child)
+  end
+  def test_find_blocks
+    document = XRT::Statement::Document.new
+    assert_equal [], document.find_blocks, 'when there is no block'
+    document << XRT::Statement::Text.new('1')
+    if_block = XRT::Statement::Block.new('[% IF a %]')
+    document << if_block
+    assert_equal [ if_block ], document.find_blocks, 'returns block'
+  end
+end
+class TestBlock < Test::Unit::TestCase
+  def test_push_child
+    block = XRT::Statement::Block.new('[% IF 1 %]')
+    assert_equal false, block.closed?
+    statement_ok = XRT::Statement::Text.new('ok')
+    statement_end = XRT::Statement::End.new('[% END %]')
+    block << statement_ok
+    assert_equal false, block.closed?
+    block << statement_end
+    assert_equal true, block.closed?
+    assert_equal block.children, [statement_ok, statement_end]
+    assert_raises {
+      block << statement_ok
+    }
+  end
+  def test_content
+    block = XRT::Statement::Block.new('[% IF 1 %]')
+    block << XRT::Statement::Text.new('ok')
+    block << XRT::Statement::End.new('[% END %]')
+    assert_equal block.content, %q{[% IF 1 %]ok[% END %]}
+  end
+end

data/test/test-syntax.rb ADDED Viewed

@@ -0,0 +1,47 @@
+require 'test/unit'
+require 'xrt/syntax'
+class TestSyntax < Test::Unit::TestCase
+  def setup
+    @syntax = XRT::Syntax.new
+  end
+  def test_remove_comment
+    assert_equal 'foo', @syntax.remove_comment('foo # bar')
+  end
+  def test_beginning_block?
+    assert @syntax.beginning_block? '[% IF 1 %]'
+    assert @syntax.beginning_block? '[% if 1 %]'
+    assert @syntax.beginning_block? '[% WHILE 1 %]'
+    assert_nil @syntax.beginning_block? '[% END # WRAPPER "wrapper.tt" WITH %]'
+    assert_nil @syntax.beginning_block? '[% "true" UNLESS false %]'
+  end
+  def test_block?
+    assert @syntax.beginning_block? '[% IF 1 %]'
+    assert @syntax.beginning_block? '[%- IF 1 -%]'
+    assert @syntax.beginning_block? "[% IF 1\nfoo\nEND %]"
+    assert_nil @syntax.beginning_block? "hi"
+    assert_nil @syntax.beginning_block? "[%"
+  end
+  def test_end_block?
+    assert @syntax.end_block? '[% END %]'
+    assert @syntax.end_block? '[% end %]'
+    assert @syntax.end_block? '[% END # WRAPPER "wrapper.tt" WITH %]'
+    assert_nil @syntax.end_block? ' END '
+  end
+  def test_block_level
+    assert_equal(0, @syntax.block_level('[% foo %]'))
+    assert_equal(1, @syntax.block_level('[% IF 1 %]'))
+    assert_equal(1, @syntax.block_level('[%- IF 1 -%]'))
+    assert_equal(0, @syntax.block_level('[% IF a THEN 1 END %]'))
+    assert_equal(0, @syntax.block_level('[% IF a THEN 1 ELSE 0 END %]'))
+    assert_equal(0, @syntax.block_level('[% a ? 1 : 0 %]'))
+    assert_equal(-1, @syntax.block_level('[% END # WRAPPER "wrapper.tt" WITH %]'))
+    assert_equal(0, @syntax.block_level('[% 2 UNLESS a %]'))
+    assert_equal(0, @syntax.block_level('[% 1 IF a %]'))
+  end
+end

data/xrt.gemspec ADDED Viewed

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'xrt/version'
+Gem::Specification.new do |spec|
+  spec.name          = "xrt"
+  spec.version       = Xrt::VERSION
+  spec.authors       = ["hitode909"]
+  spec.email         = ["hitode909@gmail.com"]
+  spec.summary       = %q{Refactoring Tool for Text::Xslate}
+  spec.homepage      = 'https://github.com/hitode909/xrt'
+  spec.license       = "MIT"
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency("test-unit")
+end

metadata ADDED Viewed

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: xrt
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- hitode909
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2016-11-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- hitode909@gmail.com
+executables:
+- xrt
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/xrt
+- lib/xrt.rb
+- lib/xrt/cli.rb
+- lib/xrt/commands.rb
+- lib/xrt/depth_checker.rb
+- lib/xrt/parser.rb
+- lib/xrt/statement.rb
+- lib/xrt/syntax.rb
+- lib/xrt/version.rb
+- sketch/dump_blocks.rb
+- sketch/dump_max_depth.rb
+- sketch/dump_tree.rb
+- sketch/find_block.rb
+- sketch/replace_block.rb
+- test/run-test.rb
+- test/test-depth_checker.rb
+- test/test-parser.rb
+- test/test-statement.rb
+- test/test-syntax.rb
+- xrt.gemspec
+homepage: https://github.com/hitode909/xrt
+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.4.5.1
+signing_key:
+specification_version: 4
+summary: Refactoring Tool for Text::Xslate
+test_files:
+- test/run-test.rb
+- test/test-depth_checker.rb
+- test/test-parser.rb
+- test/test-statement.rb
+- test/test-syntax.rb