RubyGems - xrt - Versions diffs - 0.0.1 - Mend

xrt 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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