better_html 1.0.14 → 2.0.0

data/test/better_html/tokenizer/html_erb_test.rb

@@ -1,180 +0,0 @@
-require 'test_helper'
-require 'better_html/tokenizer/html_erb'
-
-module BetterHtml
-  module Tokenizer
-    class HtmlErbTest < ActiveSupport::TestCase
-      test "text" do
-        scanner = HtmlErb.new(buffer("just some text"))
-        assert_equal 1, scanner.tokens.size
-
-        assert_attributes ({
-          type: :text,
-          loc: { begin_pos: 0, end_pos: 14, source: 'just some text' }
-        }), scanner.tokens[0]
-      end
-
-      test "statement" do
-        scanner = HtmlErb.new(buffer("<% statement %>"))
-        assert_equal 3, scanner.tokens.size
-
-        assert_attributes ({ type: :erb_begin, loc: { begin_pos: 0, end_pos: 2, source: '<%' } }), scanner.tokens[0]
-        assert_attributes ({ type: :code, loc: { begin_pos: 2, end_pos: 13, source: ' statement ' } }), scanner.tokens[1]
-        assert_attributes ({ type: :erb_end, loc: { begin_pos: 13, end_pos: 15, source: '%>' } }), scanner.tokens[2]
-      end
-
-      test "debug statement" do
-        scanner = HtmlErb.new(buffer("<%# statement %>"))
-        assert_equal 4, scanner.tokens.size
-
-        assert_attributes ({ type: :erb_begin, loc: { begin_pos: 0, end_pos: 2, source: '<%' } }), scanner.tokens[0]
-        assert_attributes ({ type: :indicator, loc: { begin_pos: 2, end_pos: 3, source: '#' } }), scanner.tokens[1]
-        assert_attributes ({ type: :code, loc: { begin_pos: 3, end_pos: 14, source: ' statement ' } }), scanner.tokens[2]
-        assert_attributes ({ type: :erb_end, loc: { begin_pos: 14, end_pos: 16, source: '%>' } }), scanner.tokens[3]
-      end
-
-      test "when multi byte characters are present in erb" do
-        code = "<% ui_helper 'your store’s' %>"
-        scanner = HtmlErb.new(buffer(code))
-        assert_equal 3, scanner.tokens.size
-
-        assert_attributes ({ type: :erb_begin, loc: { begin_pos: 0, end_pos: 2, source: '<%' } }), scanner.tokens[0]
-        assert_attributes ({ type: :code, loc: { begin_pos: 2, end_pos: 28, source: " ui_helper 'your store’s' " } }), scanner.tokens[1]
-        assert_attributes ({ type: :erb_end, loc: { begin_pos: 28, end_pos: 30, source: '%>' } }), scanner.tokens[2]
-        assert_equal code.length, scanner.current_position
-      end
-
-      test "when multi byte characters are present in text" do
-        code = "your store’s"
-        scanner = HtmlErb.new(buffer(code))
-        assert_equal 1, scanner.tokens.size
-
-        assert_attributes ({ type: :text, loc: { begin_pos: 0, end_pos: 12, source: 'your store’s' } }), scanner.tokens[0]
-        assert_equal code.length, scanner.current_position
-      end
-
-      test "when multi byte characters are present in html" do
-        code = "<div title='your store’s'>foo</div>"
-        scanner = HtmlErb.new(buffer(code))
-        assert_equal 14, scanner.tokens.size
-
-        assert_attributes ({ type: :tag_start, loc: { begin_pos: 0, end_pos: 1, source: '<' } }), scanner.tokens[0]
-        assert_attributes ({ type: :tag_name, loc: { begin_pos: 1, end_pos: 4, source: "div" } }), scanner.tokens[1]
-        assert_attributes ({ type: :whitespace, loc: { begin_pos: 4, end_pos: 5, source: " " } }), scanner.tokens[2]
-        assert_attributes ({ type: :attribute_name, loc: { begin_pos: 5, end_pos: 10, source: "title" } }), scanner.tokens[3]
-        assert_attributes ({ type: :equal, loc: { begin_pos: 10, end_pos: 11, source: "=" } }), scanner.tokens[4]
-        assert_attributes ({ type: :attribute_quoted_value_start, loc: { begin_pos: 11, end_pos: 12, source: "'" } }), scanner.tokens[5]
-        assert_attributes ({ type: :attribute_quoted_value, loc: { begin_pos: 12, end_pos: 24, source: "your store’s" } }), scanner.tokens[6]
-        assert_attributes ({ type: :attribute_quoted_value_end, loc: { begin_pos: 24, end_pos: 25, source: "'" } }), scanner.tokens[7]
-        assert_equal code.length, scanner.current_position
-      end
-
-      test "expression literal" do
-        scanner = HtmlErb.new(buffer("<%= literal %>"))
-        assert_equal 4, scanner.tokens.size
-
-        assert_attributes ({ type: :erb_begin, loc: { begin_pos: 0, end_pos: 2, source: '<%' } }), scanner.tokens[0]
-        assert_attributes ({ type: :indicator, loc: { begin_pos: 2, end_pos: 3, source: '=' } }), scanner.tokens[1]
-        assert_attributes ({ type: :code, loc: { begin_pos: 3, end_pos: 12, source: ' literal ' } }), scanner.tokens[2]
-        assert_attributes ({ type: :erb_end, loc: { begin_pos: 12, end_pos: 14, source: '%>' } }), scanner.tokens[3]
-      end
-
-      test "expression escaped" do
-        scanner = HtmlErb.new(buffer("<%== escaped %>"))
-        assert_equal 4, scanner.tokens.size
-
-        assert_attributes ({ type: :erb_begin, loc: { begin_pos: 0, end_pos: 2, source: '<%' } }), scanner.tokens[0]
-        assert_attributes ({ type: :indicator, loc: { begin_pos: 2, end_pos: 4, source: '==' } }), scanner.tokens[1]
-        assert_attributes ({ type: :code, loc: { begin_pos: 4, end_pos: 13, source: ' escaped ' } }), scanner.tokens[2]
-        assert_attributes ({ type: :erb_end, loc: { begin_pos: 13, end_pos: 15, source: '%>' } }), scanner.tokens[3]
-      end
-
-      test "line number for multi-line statements" do
-        scanner = HtmlErb.new(buffer("before <% multi\nline %> after"))
-        assert_equal 5, scanner.tokens.size
-
-        assert_attributes ({ type: :text, loc: { line: 1, source: 'before ' } }), scanner.tokens[0]
-        assert_attributes ({ type: :erb_begin, loc: { line: 1, source: '<%' } }), scanner.tokens[1]
-        assert_attributes ({ type: :code, loc: { line: 1, start_line: 1, stop_line: 2, source: " multi\nline " } }), scanner.tokens[2]
-        assert_attributes ({ type: :erb_end, loc: { line: 2, source: "%>" } }), scanner.tokens[3]
-        assert_attributes ({ type: :text, loc: { line: 2, source: " after" } }), scanner.tokens[4]
-      end
-
-      test "multi-line statements with trim" do
-        scanner = HtmlErb.new(buffer("before\n<% multi\nline -%>\nafter"))
-        assert_equal 7, scanner.tokens.size
-
-        assert_attributes ({ type: :text, loc: { line: 1, source: "before\n" } }), scanner.tokens[0]
-        assert_attributes ({ type: :erb_begin, loc: { line: 2, source: '<%' } }), scanner.tokens[1]
-        assert_attributes ({ type: :code, loc: { line: 2, source: " multi\nline " } }), scanner.tokens[2]
-        assert_attributes ({ type: :trim, loc: { line: 3, source: "-" } }), scanner.tokens[3]
-        assert_attributes ({ type: :erb_end, loc: { line: 3, source: "%>" } }), scanner.tokens[4]
-        assert_attributes ({ type: :text, loc: { line: 3, source: "\n" } }), scanner.tokens[5]
-        assert_attributes ({ type: :text, loc: { line: 4, source: "after" } }), scanner.tokens[6]
-      end
-
-      test "right trim with =%>" do
-        scanner = HtmlErb.new(buffer("<% trim =%>"))
-        assert_equal 4, scanner.tokens.size
-
-        assert_attributes ({ type: :erb_begin, loc: { line: 1, source: '<%' } }), scanner.tokens[0]
-        assert_attributes ({ type: :code, loc: { line: 1, source: " trim " } }), scanner.tokens[1]
-        assert_attributes ({ type: :trim, loc: { line: 1, source: "=" } }), scanner.tokens[2]
-        assert_attributes ({ type: :erb_end, loc: { line: 1, source: "%>" } }), scanner.tokens[3]
-      end
-
-      test "multi-line expression with trim" do
-        scanner = HtmlErb.new(buffer("before\n<%= multi\nline -%>\nafter"))
-        assert_equal 8, scanner.tokens.size
-
-        assert_attributes ({ type: :text, loc: { line: 1, source: "before\n" } }), scanner.tokens[0]
-        assert_attributes ({ type: :erb_begin, loc: { line: 2, source: '<%' } }), scanner.tokens[1]
-        assert_attributes ({ type: :indicator, loc: { line: 2, source: '=' } }), scanner.tokens[2]
-        assert_attributes ({ type: :code, loc: { line: 2, source: " multi\nline " } }), scanner.tokens[3]
-        assert_attributes ({ type: :trim, loc: { line: 3, source: "-" } }), scanner.tokens[4]
-        assert_attributes ({ type: :erb_end, loc: { line: 3, source: "%>" } }), scanner.tokens[5]
-        assert_attributes ({ type: :text, loc: { line: 3, source: "\n" } }), scanner.tokens[6]
-        assert_attributes ({ type: :text, loc: { line: 4, source: "after" } }), scanner.tokens[7]
-      end
-
-      test "line counts with comments" do
-        scanner = HtmlErb.new(buffer("before\n<%# BO$$ Mode %>\nafter"))
-        assert_equal 7, scanner.tokens.size
-
-        assert_attributes ({ type: :text, loc: { line: 1, source: "before\n" } }), scanner.tokens[0]
-        assert_attributes ({ type: :erb_begin, loc: { line: 2, source: '<%' } }), scanner.tokens[1]
-        assert_attributes ({ type: :indicator, loc: { line: 2, source: '#' } }), scanner.tokens[2]
-        assert_attributes ({ type: :code, loc: { line: 2, source: " BO$$ Mode " } }), scanner.tokens[3]
-        assert_attributes ({ type: :erb_end, loc: { line: 2, source: "%>" } }), scanner.tokens[4]
-        assert_attributes ({ type: :text, loc: { line: 2, source: "\n" } }), scanner.tokens[5]
-        assert_attributes ({ type: :text, loc: { line: 3, source: "after" } }), scanner.tokens[6]
-      end
-
-      test "escaped opening ERB tag <%%" do
-        scanner = HtmlErb.new(buffer("just some <%%= text %> no erb"))
-        assert_equal 6, scanner.tokens.size
-
-        assert_attributes ({ type: :text, loc: { line: 1, source: "just some " } }), scanner.tokens[0]
-        assert_attributes ({ type: :erb_begin, loc: { line: 1, source: '<%' } }), scanner.tokens[1]
-        assert_attributes ({ type: :indicator, loc: { line: 1, source: "%" } }), scanner.tokens[2]
-        assert_attributes ({ type: :code, loc: { line: 1, source: "= text " } }), scanner.tokens[3]
-        assert_attributes ({ type: :erb_end, loc: { line: 1, source: "%>" } }), scanner.tokens[4]
-        assert_attributes ({ type: :text, loc: { line: 1, source: " no erb" } }), scanner.tokens[5]
-      end
-
-      private
-
-      def assert_attributes(attributes, token)
-        attributes.each do |key, value|
-          if value.nil?
-            assert_nil token.send(key)
-          elsif value.is_a?(Hash)
-            assert_attributes(value, token.send(key))
-          else
-            assert_equal value, token.send(key)
-          end
-        end
-      end
-    end
-  end
-end

data/test/better_html/tokenizer/html_lodash_test.rb

@@ -1,98 +0,0 @@
-require 'test_helper'
-require 'better_html/tokenizer/html_lodash'
-
-module BetterHtml
-  module Tokenizer
-    class HtmlLodashTest < ActiveSupport::TestCase
-      test "matches text" do
-        scanner = HtmlLodash.new(buffer("just some text"))
-        assert_equal 1, scanner.tokens.size
-
-        assert_attributes ({ type: :text, loc: { begin_pos: 0, end_pos: 14, source: "just some text" } }), scanner.tokens[0]
-      end
-
-      test "matches strings to be escaped" do
-        scanner = HtmlLodash.new(buffer("[%= foo %]"))
-        assert_equal 4, scanner.tokens.size
-
-        assert_attributes ({ type: :lodash_begin, loc: { begin_pos: 0, end_pos: 2, source: "[%" } }), scanner.tokens[0]
-        assert_attributes ({ type: :indicator, loc: { begin_pos: 2, end_pos: 3, source: "=" } }), scanner.tokens[1]
-        assert_attributes ({ type: :code, loc: { begin_pos: 3, end_pos: 8, source: " foo " } }), scanner.tokens[2]
-        assert_attributes ({ type: :lodash_end, loc: { begin_pos: 8, end_pos: 10, source: "%]" } }), scanner.tokens[3]
-      end
-
-      test "matches interpolate" do
-        scanner = HtmlLodash.new(buffer("[%! foo %]"))
-        assert_equal 4, scanner.tokens.size
-
-        assert_attributes ({ type: :lodash_begin, loc: { begin_pos: 0, end_pos: 2, source: "[%" } }), scanner.tokens[0]
-        assert_attributes ({ type: :indicator, loc: { begin_pos: 2, end_pos: 3, source: "!" } }), scanner.tokens[1]
-        assert_attributes ({ type: :code, loc: { begin_pos: 3, end_pos: 8, source: " foo " } }), scanner.tokens[2]
-        assert_attributes ({ type: :lodash_end, loc: { begin_pos: 8, end_pos: 10, source: "%]" } }), scanner.tokens[3]
-      end
-
-      test "matches statement" do
-        scanner = HtmlLodash.new(buffer("[% foo %]"))
-        assert_equal 3, scanner.tokens.size
-
-        assert_attributes ({ type: :lodash_begin, loc: { begin_pos: 0, end_pos: 2, source: "[%" } }), scanner.tokens[0]
-        assert_attributes ({ type: :code, loc: { begin_pos: 2, end_pos: 7, source: " foo " } }), scanner.tokens[1]
-        assert_attributes ({ type: :lodash_end, loc: { begin_pos: 7, end_pos: 9, source: "%]" } }), scanner.tokens[2]
-      end
-
-      test "matches text before and after" do
-        scanner = HtmlLodash.new(buffer("before\n[%= foo %]\nafter"))
-        assert_equal 6, scanner.tokens.size
-
-        assert_attributes ({ type: :text, loc: { begin_pos: 0, end_pos: 7, source: "before\n" } }), scanner.tokens[0]
-        assert_attributes ({ type: :lodash_begin, loc: { begin_pos: 7, end_pos: 9, source: "[%" } }), scanner.tokens[1]
-        assert_attributes ({ type: :indicator, loc: { begin_pos: 9, end_pos: 10, source: "=" } }), scanner.tokens[2]
-        assert_attributes ({ type: :code, loc: { begin_pos: 10, end_pos: 15, source: " foo " } }), scanner.tokens[3]
-        assert_attributes ({ type: :lodash_end, loc: { begin_pos: 15, end_pos: 17, source: "%]" } }), scanner.tokens[4]
-        assert_attributes ({ type: :text, loc: { begin_pos: 17, end_pos: 23, source: "\nafter" } }), scanner.tokens[5]
-      end
-
-      test "matches multiple" do
-        scanner = HtmlLodash.new(buffer("[% if() { %][%= foo %][% } %]"))
-        assert_equal 10, scanner.tokens.size
-
-        assert_attributes ({ type: :lodash_begin, loc: { source: "[%" } }), scanner.tokens[0]
-        assert_attributes ({ type: :code, loc: { source: " if() { " } }), scanner.tokens[1]
-        assert_attributes ({ type: :lodash_end, loc: { source: "%]" } }), scanner.tokens[2]
-
-        assert_attributes ({ type: :lodash_begin, loc: { source: "[%" } }), scanner.tokens[3]
-        assert_attributes ({ type: :indicator, loc: { source: "=" } }), scanner.tokens[4]
-        assert_attributes ({ type: :code, loc: { source: " foo " } }), scanner.tokens[5]
-        assert_attributes ({ type: :lodash_end, loc: { source: "%]" } }), scanner.tokens[6]
-
-        assert_attributes ({ type: :lodash_begin, loc: { source: "[%" } }), scanner.tokens[7]
-        assert_attributes ({ type: :code, loc: { source: " } " } }), scanner.tokens[8]
-        assert_attributes ({ type: :lodash_end, loc: { source: "%]" } }), scanner.tokens[9]
-      end
-
-      test "parses out html correctly" do
-        scanner = HtmlLodash.new(buffer('<div class="[%= foo %]">'))
-        assert_equal 12, scanner.tokens.size
-        assert_equal [:tag_start, :tag_name, :whitespace, :attribute_name,
-          :equal, :attribute_quoted_value_start,
-          :lodash_begin, :indicator, :code, :lodash_end,
-          :attribute_quoted_value_end, :tag_end], scanner.tokens.map(&:type)
-        assert_equal ["<", "div", " ", "class", "=", "\"", "[%", "=", " foo ", "%]", "\"", ">"], scanner.tokens.map(&:loc).map(&:source)
-      end
-
-      private
-
-      def assert_attributes(attributes, token)
-        attributes.each do |key, value|
-          if value.nil?
-            assert_nil token.send(key)
-          elsif value.is_a?(Hash)
-            assert_attributes(value, token.send(key))
-          else
-            assert_equal value, token.send(key)
-          end
-        end
-      end
-    end
-  end
-end

data/test/better_html/tokenizer/location_test.rb

@@ -1,75 +0,0 @@
-require 'test_helper'
-require 'better_html/tokenizer/location'
-
-module BetterHtml
-  module Tokenizer
-    class LocationTest < ActiveSupport::TestCase
-      test "location start out of bounds" do
-        e = assert_raises(ArgumentError) do
-          Location.new(buffer("foo"), 5, 6)
-        end
-        assert_equal "begin_pos location 5 is out of range for document of size 3", e.message
-      end
-
-      test "location stop out of bounds" do
-        e = assert_raises(ArgumentError) do
-          Location.new(buffer("foo"), 2, 6)
-        end
-        assert_equal "end_pos location 6 is out of range for document of size 3", e.message
-      end
-
-      test "location stop < start" do
-        e = assert_raises(ArgumentError) do
-          Location.new(buffer("aaaaaa"), 5, 2)
-        end
-        assert_equal "Parser::Source::Range: end_pos must not be less than begin_pos", e.message
-      end
-
-      test "location stop == start" do
-        loc = Location.new(buffer("aaaaaa"), 5, 5)
-        assert_equal "", loc.source
-        assert_equal 0, loc.size
-      end
-
-      test "end_pos is stop+1" do
-        loc = Location.new(buffer("aaaaaa"), 5, 5)
-        assert_equal 5, loc.end_pos
-      end
-
-      test "range is exclusive of last char" do
-        loc = Location.new(buffer("aaaaaa"), 5, 5)
-        assert_equal 5...5, loc.range
-      end
-
-      test "location calulates start and stop line and column" do
-        loc = Location.new(buffer("foo\nbar\nbaz"), 5, 10)
-
-        assert_equal "ar\nba", loc.source
-        assert_equal 2, loc.start_line
-        assert_equal 1, loc.start_column
-        assert_equal 3, loc.stop_line
-        assert_equal 2, loc.stop_column
-      end
-
-      test "line_source_with_underline" do
-        loc = Location.new(buffer("ui_helper(foo)"), 10, 13)
-
-        assert_equal "foo", loc.source
-        assert_equal <<~EOL.strip, loc.line_source_with_underline
-          ui_helper(foo)
-                    ^^^
-        EOL
-      end
-
-      test "line_source_with_underline removes empty spaces" do
-        loc = Location.new(buffer("   \t   ui_helper(foo)"), 17, 20)
-
-        assert_equal "foo", loc.source
-        assert_equal <<~EOL.strip, loc.line_source_with_underline
-          ui_helper(foo)
-                    ^^^
-        EOL
-      end
-    end
-  end
-end

data/test/better_html/tokenizer/token_array_test.rb

@@ -1,145 +0,0 @@
-require 'test_helper'
-require 'better_html/tokenizer/token'
-require 'better_html/tokenizer/location'
-require 'better_html/tokenizer/token_array'
-
-module BetterHtml
-  module Tokenizer
-    class TokenArrayTest < ActiveSupport::TestCase
-      setup do
-        @document = "<x>"
-        @buffer = buffer(@document)
-        @tokens = [
-          Token.new(type: :lquote, loc: Location.new(@buffer, 0, 0)),
-          Token.new(type: :name, loc: Location.new(@buffer, 1, 1)),
-          Token.new(type: :rquote, loc: Location.new(@buffer, 2, 2)),
-        ]
-        @array = TokenArray.new(@tokens)
-      end
-
-      test "size" do
-        assert_equal 3, @array.size
-      end
-
-      test "size for empty array" do
-        @array = TokenArray.new([])
-        assert_equal 0, @array.size
-      end
-
-      test "shift returns element from beginning of array" do
-        assert_equal @tokens.first, @array.shift
-      end
-
-      test "shift decreases the size by 1" do
-        assert_difference(-> { @array.size }, -1) do
-          @array.shift
-        end
-      end
-
-      test "after shift, current element is changed" do
-        assert_equal @tokens.first, @array.current
-        assert_equal @tokens.first, @array.shift
-        assert_equal @tokens.second, @array.current
-      end
-
-      test "pop returns element from the end of array" do
-        assert_equal @tokens.last, @array.pop
-      end
-
-      test "pop decreases the size by 1" do
-        assert_difference(-> { @array.size }, -1) do
-          @array.pop
-        end
-      end
-
-      test "after pop, last element is changed" do
-        assert_equal @tokens.last, @array.last
-        assert_equal @tokens.last, @array.pop
-        assert_equal @tokens.second, @array.last
-      end
-
-      test "current returns element from beginning of array" do
-        assert_equal @tokens.first, @array.current
-      end
-
-      test "current does not change size" do
-        assert_no_difference(-> { @array.size }) do
-          @array.current
-        end
-      end
-
-      test "last returns element from the end of array" do
-        assert_equal @tokens.last, @array.last
-      end
-
-      test "last does not change size" do
-        assert_no_difference(-> { @array.size }) do
-          @array.last
-        end
-      end
-
-      test "empty?" do
-        refute_predicate @array, :empty?
-        3.times { @array.shift }
-        assert_predicate @array, :empty?
-      end
-
-      test "any?" do
-        assert_predicate @array, :any?
-        3.times { @array.shift }
-        refute_predicate @array, :any?
-      end
-
-      test "current is nil when array is empty" do
-        @array = TokenArray.new([])
-        assert_nil @array.current
-      end
-
-      test "last is nil when array is empty" do
-        @array = TokenArray.new([])
-        assert_nil @array.last
-      end
-
-      test "shift raises for empty array" do
-        @array = TokenArray.new([])
-        e = assert_raises(RuntimeError) do
-          @array.shift
-        end
-        assert_equal 'no tokens left to shift', e.message
-      end
-
-      test "pop raises for empty array" do
-        @array = TokenArray.new([])
-        e = assert_raises(RuntimeError) do
-          @array.pop
-        end
-        assert_equal 'no tokens left to pop', e.message
-      end
-
-      test "trim takes elements from the beginning of array" do
-        assert_difference(-> { @array.size }, -1) do
-          @array.trim(:lquote)
-        end
-
-        assert_equal @tokens.second, @array.current
-      end
-
-      test "trim takes elements from the end of array" do
-        assert_difference(-> { @array.size }, -1) do
-          @array.trim(:rquote)
-        end
-
-        assert_equal @tokens.second, @array.last
-      end
-
-      test "trim does not change array when element types are not at front nor back of array" do
-        assert_no_difference(-> { @array.size }) do
-          @array.trim(:name)
-        end
-
-        assert_equal @tokens.first, @array.current
-        assert_equal @tokens.last, @array.last
-      end
-    end
-  end
-end

data/test/better_html/tokenizer/token_test.rb

@@ -1,15 +0,0 @@
-require 'test_helper'
-require 'better_html/tokenizer/location'
-require 'better_html/tokenizer/token'
-
-module BetterHtml
-  module Tokenizer
-    class TokenTest < ActiveSupport::TestCase
-      test "token inspect" do
-        loc = Location.new(buffer("foo"), 0, 3)
-        token = Token.new(type: :foo, loc: loc)
-        assert_equal "t(:foo, \"foo\")", token.inspect
-      end
-    end
-  end
-end

data/test/dummy/README.rdoc

@@ -1,28 +0,0 @@
-== README
-
-This README would normally document whatever steps are necessary to get the
-application up and running.
-
-Things you may want to cover:
-
-* Ruby version
-
-* System dependencies
-
-* Configuration
-
-* Database creation
-
-* Database initialization
-
-* How to run the test suite
-
-* Services (job queues, cache servers, search engines, etc.)
-
-* Deployment instructions
-
-* ...
-
-
-Please feel free to use a different markup language if you do not plan to run
-<tt>rake doc:app</tt>.

data/test/dummy/Rakefile

@@ -1,6 +0,0 @@
-# Add your own tasks in files placed in lib/tasks ending in .rake,
-# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
-
-require File.expand_path('../config/application', __FILE__)
-
-Rails.application.load_tasks

data/test/dummy/app/assets/javascripts/application.js

@@ -1,13 +0,0 @@
-// This is a manifest file that'll be compiled into application.js, which will include all the files
-// listed below.
-//
-// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
-// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
-//
-// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
-// compiled file.
-//
-// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
-// about supported directives.
-//
-//= require_tree .

data/test/dummy/app/assets/stylesheets/application.css

@@ -1,15 +0,0 @@
-/*
- * This is a manifest file that'll be compiled into application.css, which will include all the files
- * listed below.
- *
- * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
- * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
- *
- * You're free to add application-wide styles to this file and they'll appear at the bottom of the
- * compiled file so the styles you add here take precedence over styles defined in any styles
- * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
- * file per style scope.
- *
- *= require_tree .
- *= require_self
- */

data/test/dummy/app/controllers/application_controller.rb

@@ -1,5 +0,0 @@
-class ApplicationController < ActionController::Base
-  # Prevent CSRF attacks by raising an exception.
-  # For APIs, you may want to use :null_session instead.
-  protect_from_forgery with: :exception
-end

data/test/dummy/app/helpers/application_helper.rb

@@ -1,2 +0,0 @@
-module ApplicationHelper
-end

data/test/dummy/app/views/layouts/application.html.erb

@@ -1,14 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <title>Dummy</title>
-  <%= stylesheet_link_tag    'application', media: 'all', 'data-turbolinks-track' => true %>
-  <%= javascript_include_tag 'application', 'data-turbolinks-track' => true %>
-  <%= csrf_meta_tags %>
-</head>
-<body>
-
-<%= yield %>
-
-</body>
-</html>

data/test/dummy/bin/bundle

@@ -1,3 +0,0 @@
-#!/usr/bin/env ruby
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
-load Gem.bin_path('bundler', 'bundle')

data/test/dummy/bin/rails

@@ -1,4 +0,0 @@
-#!/usr/bin/env ruby
-APP_PATH = File.expand_path('../../config/application', __FILE__)
-require_relative '../config/boot'
-require 'rails/commands'

data/test/dummy/bin/rake

@@ -1,4 +0,0 @@
-#!/usr/bin/env ruby
-require_relative '../config/boot'
-require 'rake'
-Rake.application.run

data/test/dummy/bin/setup

@@ -1,29 +0,0 @@
-#!/usr/bin/env ruby
-require 'pathname'
-
-# path to your application root.
-APP_ROOT = Pathname.new File.expand_path('../../',  __FILE__)
-
-Dir.chdir APP_ROOT do
-  # This script is a starting point to setup your application.
-  # Add necessary setup steps to this file:
-
-  puts "== Installing dependencies =="
-  system "gem install bundler --conservative"
-  system "bundle check || bundle install"
-
-  # puts "\n== Copying sample files =="
-  # unless File.exist?("config/database.yml")
-  #   system "cp config/database.yml.sample config/database.yml"
-  # end
-
-  puts "\n== Preparing database =="
-  system "bin/rake db:setup"
-
-  puts "\n== Removing old logs and tempfiles =="
-  system "rm -f log/*"
-  system "rm -rf tmp/cache"
-
-  puts "\n== Restarting application server =="
-  system "touch tmp/restart.txt"
-end