hamlit 1.7.2 → 2.0.1

data/spec/rails/public/robots.txt

@@ -1,5 +0,0 @@
-# See http://www.robotstxt.org/robotstxt.html for documentation on how to use the robots.txt file
-#
-# To ban all spiders from the entire site uncomment the next two lines:
-# User-agent: *
-# Disallow: /

data/spec/rails/spec/hamlit_spec.rb

@@ -1,123 +0,0 @@
-require 'rails_helper'
-
-describe 'Hamlit rails integration', type: :request do
-  it 'renders views' do
-    get root_path
-    expect(response).to be_ok
-    expect(response).to render_template('application/index')
-    expect(response).to render_template('layouts/application')
-    expect(response.body).to include('<span>Hamlit</span>')
-  end
-
-  it 'renders params' do
-    get users_path(q: 'hello')
-    expect(response.body).to include('<span>hello</span>')
-  end
-
-  it 'renders instance variable' do
-    get users_path
-    expect(response.body).to include('<p>k0kubun</p>')
-  end
-
-  it 'does not escape the object whose to_s returns SafeBuffer' do
-    get safe_buffer_users_path
-    expect(response.body).to include('<safe>')
-  end
-
-  it 'renders a complex old attributes' do
-    get old_attributes_users_path
-    expect(response.body).to include("<a value='foo 1'></a>")
-    expect(response.body).to include("<span data-value='foo 2'></span>")
-    expect(response.body).to include("<div class='foo' data-value='foo 3'></div>")
-    expect(response.body).to include("<a data-value='foo 4'></a>")
-    expect(response.body).to include("<a data-value='[{:count=&gt;1}]'></a>")
-  end
-
-  it 'renders multi-line script inside a tag' do
-    get inline_users_path
-    expect(response.body).to include('<span><a data-url="2" href="#">1</a></span>')
-    expect(response.body).to include('<span><a data-url="4" href="#">3</a></span>')
-    expect(response.body).to include('<span><a data-url="6" href="#">5</a></span>')
-    expect(response.body).to include('<span><a data-url="6" href="#">5</a></span>')
-  end
-
-  describe 'escaping' do
-    it 'escapes script' do
-      get users_path(q: '<script>alert("a");</script>')
-      expect(response.body).to include(
-        '<span>&lt;script&gt;alert(&quot;a&quot;);&lt;/script&gt;</span>',
-      )
-    end
-
-    it 'escapes block script' do
-      get users_path(q: '<>')
-      expect(response.body).to include(<<-HTML.strip_heredoc)
-        <i>
-        &lt;&gt;
-        &lt;&gt;</i>
-      HTML
-    end
-  end
-
-  describe 'rails helpers' do
-    it 'renders rails helper' do
-      get users_path
-      expect(response.body).to include('<a href="/">root</a>')
-    end
-
-    it 'allows capture method to work' do
-      get capture_users_path
-      expect(response.body).to include(<<-HTML.strip_heredoc)
-        <div class='capture'><span>
-        <p>Capture</p>
-        </span>
-        </div>
-      HTML
-    end
-
-    it 'renders haml tags in the form block' do
-      get form_users_path
-      expect(response.body).to include('row')
-    end
-
-    it 'renders whitespace removal inside #capture' do
-      get whitespace_users_path
-      expect(response.body).to include('<a href="#">foo</a>')
-    end
-  end
-
-  describe 'haml helpers' do
-    it 'accepts find_and_preserve' do
-      get helpers_users_path
-      expect(response.body).to include(<<-HTML.strip_heredoc)
-        Foo
-        <pre>Bar&#x000A;Baz</pre>
-      HTML
-    end
-
-    it 'accepts capture_haml' do
-      get capture_users_path
-      expect(response.body).to include(<<-HTML.strip_heredoc)
-        <div class='capture'><span>
-        <p>Capture</p>
-        </span>
-        </div>
-      HTML
-    end
-
-    it 'renders succeed' do
-      get helpers_users_path
-      expect(response.body).to include('<i>succeed</i>&amp;')
-    end
-
-    it 'renders precede' do
-      get helpers_users_path
-      expect(response.body).to include('&amp;<i>precede</i>')
-    end
-
-    it 'renders surround' do
-      get helpers_users_path
-      expect(response.body).to include('&lt;<i>surround</i>&gt;')
-    end
-  end
-end

data/spec/rails/spec/rails_helper.rb

@@ -1,56 +0,0 @@
-# This file is copied to spec/ when you run 'rails generate rspec:install'
-ENV['RAILS_ENV'] ||= 'test'
-require 'spec_helper'
-require File.expand_path('../../config/environment', __FILE__)
-require 'rspec/rails'
-# Add additional requires below this line. Rails is not loaded until this point!
-
-# Requires supporting ruby files with custom matchers and macros, etc, in
-# spec/support/ and its subdirectories. Files matching `spec/**/*_spec.rb` are
-# run as spec files by default. This means that files in spec/support that end
-# in _spec.rb will both be required and run as specs, causing the specs to be
-# run twice. It is recommended that you do not name files matching this glob to
-# end with _spec.rb. You can configure this pattern with the --pattern
-# option on the command line or in ~/.rspec, .rspec or `.rspec-local`.
-#
-# The following line is provided for convenience purposes. It has the downside
-# of increasing the boot-up time by auto-requiring all files in the support
-# directory. Alternatively, in the individual `*_spec.rb` files, manually
-# require only the support files necessary.
-#
-# Dir[Rails.root.join('spec/support/**/*.rb')].each { |f| require f }
-
-# Checks for pending migrations before tests are run.
-# If you are not using ActiveRecord, you can remove this line.
-ActiveRecord::Migration.maintain_test_schema!
-
-RSpec.configure do |config|
-  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
-  config.fixture_path = "#{::Rails.root}/spec/fixtures"
-
-  # If you're not using ActiveRecord, or you'd prefer not to run each of your
-  # examples within a transaction, remove the following line or assign false
-  # instead of true.
-  config.use_transactional_fixtures = true
-
-  # RSpec Rails can automatically mix in different behaviours to your tests
-  # based on their file location, for example enabling you to call `get` and
-  # `post` in specs under `spec/controllers`.
-  #
-  # You can disable this behaviour by removing the line below, and instead
-  # explicitly tag your specs with their type, e.g.:
-  #
-  #     RSpec.describe UsersController, :type => :controller do
-  #       # ...
-  #     end
-  #
-  # The different available types are documented in the features, such as in
-  # https://relishapp.com/rspec/rspec-rails/docs
-  config.infer_spec_type_from_file_location!
-end
-
-# Require factories
-Dir[Rails.root.join("spec/factories/**/*.rb")].each { |f| require f }
-
-# Require support files
-Dir[Rails.root.join("spec/support/**/*.rb")].each { |f| require f }

data/spec/rails/spec/spec_helper.rb

@@ -1,91 +0,0 @@
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# The generated `.rspec` file contains `--require spec_helper` which will cause
-# this file to always be loaded, without a need to explicitly require it in any
-# files.
-#
-# Given that it is always loaded, you are encouraged to keep this file as
-# light-weight as possible. Requiring heavyweight dependencies from this file
-# will add to the boot time of your test suite on EVERY test run, even for an
-# individual file that may not need all of that loaded. Instead, consider making
-# a separate helper file that requires the additional dependencies and performs
-# the additional setup, and require it from the spec files that actually need
-# it.
-#
-# The `.rspec` file also contains a few flags that are not defaults but that
-# users commonly want.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-RSpec.configure do |config|
-  # rspec-expectations config goes here. You can use an alternate
-  # assertion/expectation library such as wrong or the stdlib/minitest
-  # assertions if you prefer.
-  config.expect_with :rspec do |expectations|
-    # This option will default to `true` in RSpec 4. It makes the `description`
-    # and `failure_message` of custom matchers include text for helper methods
-    # defined using `chain`, e.g.:
-    #     be_bigger_than(2).and_smaller_than(4).description
-    #     # => "be bigger than 2 and smaller than 4"
-    # ...rather than:
-    #     # => "be bigger than 2"
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  # rspec-mocks config goes here. You can use an alternate test double
-  # library (such as bogus or mocha) by changing the `mock_with` option here.
-  config.mock_with :rspec do |mocks|
-    # Prevents you from mocking or stubbing a method that does not exist on
-    # a real object. This is generally recommended, and will default to
-    # `true` in RSpec 4.
-    mocks.verify_partial_doubles = true
-  end
-
-# The settings below are suggested to provide a good initial experience
-# with RSpec, but feel free to customize to your heart's content.
-=begin
-  # These two settings work together to allow you to limit a spec run
-  # to individual examples or groups you care about by tagging them with
-  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
-  # get run.
-  config.filter_run :focus
-  config.run_all_when_everything_filtered = true
-
-  # Limits the available syntax to the non-monkey patched syntax that is
-  # recommended. For more details, see:
-  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
-  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
-  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
-  config.disable_monkey_patching!
-
-  # This setting enables warnings. It's recommended, but in some cases may
-  # be too noisy due to issues in dependencies.
-  config.warnings = true
-
-  # Many RSpec users commonly either run the entire suite or an individual
-  # file, and it's useful to allow more verbose output when running an
-  # individual spec file.
-  if config.files_to_run.one?
-    # Use the documentation formatter for detailed output,
-    # unless a formatter has already been configured
-    # (e.g. via a command-line flag).
-    config.default_formatter = 'doc'
-  end
-
-  # Print the 10 slowest examples and example groups at the
-  # end of the spec run, to help surface which specs are running
-  # particularly slow.
-  config.profile_examples = 10
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = :random
-
-  # Seed global randomization in this process using the `--seed` CLI option.
-  # Setting this allows you to use `--seed` to deterministically reproduce
-  # test failures related to randomization by passing the same `--seed` value
-  # as the one that triggered the failure.
-  Kernel.srand config.seed
-=end
-end

data/spec/spec_helper.rb

@@ -1,36 +0,0 @@
-require 'coveralls'
-require 'simplecov'
-require 'unindent'
-require_relative 'spec_helper/document_generator'
-require_relative 'spec_helper/render_helper'
-require_relative 'spec_helper/test_case'
-
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-  SimpleCov::Formatter::HTMLFormatter,
-  Coveralls::SimpleCov::Formatter
-]
-SimpleCov.start
-
-RSpec.configure do |config|
-  config.include RenderHelper
-
-  config.expect_with :rspec do |expectations|
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-
-  config.around(:each, skipdoc: true) do |example|
-    TestCase.skipdoc do
-      example.run
-    end
-  end
-
-  config.after(:suite) do
-    if DocumentGenerator.generate_docs?
-      DocumentGenerator.generate_docs!
-    end
-  end
-end

data/spec/spec_helper/document_generator.rb

@@ -1,93 +0,0 @@
-require 'singleton'
-
-class DocumentGenerator
-  class << self
-    def incompatibilities
-      @incompatibilities ||= []
-    end
-
-    def generate_docs!
-      prepare_dirs!
-
-      [nil, 'haml', 'faml'].each do |impl|
-        generate_toc!(impl)
-        generate_doc!(impl)
-      end
-    end
-
-    def generate_docs?
-      ENV['AUTODOC']
-    end
-
-    def register_test!(test)
-      incompatibilities << test unless @skipdoc
-    end
-
-    def skipdoc(&block)
-      @skipdoc = true
-      block.call
-    ensure
-      @skipdoc = false
-    end
-
-    private
-
-    def generate_doc!(impl)
-      incompatibilities_for(impl).group_by(&:doc_path).each do |path, tests|
-        doc = tests.sort_by(&:lineno).map { |t| t.document(impl) }.join("\n")
-        full_path = File.join(*[doc_dir, impl, path].compact)
-        File.write(full_path, doc)
-      end
-    end
-
-    def generate_toc!(impl = nil)
-      path = File.join(*[doc_dir, impl, 'README.md'].compact)
-      File.write(path, table_of_contents_for(impl))
-    end
-
-    def table_of_contents_for(impl = nil)
-      toc = "# Hamlit incompatibilities\nThis is a document generated from RSpec test cases.  "
-      toc << "\n#{target_description(impl)}"
-
-      incompatibilities_for(impl).group_by(&:dir).each do |dir, tests|
-        toc << "\n\n## #{dir}\n"
-        tests.map { |t| [t.spec_path, t.doc_path] }.uniq.each do |spec_path, doc_path|
-          toc << "- [#{spec_path}](#{doc_path})\n"
-        end
-      end
-      toc
-    end
-
-    def incompatibilities_for(impl)
-      return incompatibilities unless impl
-      incompatibilities.select { |t| t.send(:"#{impl}_html") != t.hamlit_html }
-    end
-
-    def target_description(impl)
-      case impl
-      when 'haml'
-        'Showing incompatibilities against [Haml](https://github.com/haml/haml).'
-      when 'faml'
-        'Showing incompatibilities against [Faml](https://github.com/eagletmt/faml).'
-      else
-        'Showing incompatibilities against [Haml](https://github.com/haml/haml) and [Faml](https://github.com/eagletmt/faml).'
-      end
-    end
-
-    def prepare_dirs!
-      system("rm -rf #{doc_dir}")
-      incompatibilities.map(&:dir).uniq.each do |dir|
-        system("mkdir -p #{File.join(doc_dir, dir)}")
-      end
-      %w[haml faml].each do |impl|
-        incompatibilities.map(&:dir).uniq.each do |dir|
-          system("mkdir -p #{File.join(doc_dir, impl, dir)}")
-        end
-      end
-    end
-
-    def doc_dir
-      @doc_dir ||= File.expand_path('./doc')
-    end
-  end
-end

data/spec/spec_helper/render_helper.rb

@@ -1,120 +0,0 @@
-require 'haml'
-require 'faml'
-require 'hamlit'
-require 'unindent'
-
-module RenderHelper
-  DEFAULT_OPTIONS = { ugly: true, escape_html: true }.freeze
-
-  def parse_string(str)
-    Hamlit::Parser.new.call(str)
-  end
-
-  def render_string(str, options = {})
-    eval Hamlit::Engine.new(options).call(str)
-  end
-
-  def assert_render(haml, html, options = {})
-    errs  = array_wrap(options.delete(:error_with) || [])
-    impls = array_wrap(options.delete(:compatible_only) || [:haml, :faml] - errs)
-    fails = [:haml, :faml] - impls - errs
-
-    test = TestCase.new
-    test.src_haml = haml.unindent
-    test.hamlit_html = html.unindent
-
-    expect(render_string(test.src_haml, options)).to eq(test.hamlit_html)
-    impls.each { |i| expect_compatibility(i, test, options) }
-    errs.each  { |i| expect_compatibility(i, test, options, type: :error) }
-    fails.each { |i| expect_compatibility(i, test, options, type: :failure) }
-
-    if DocumentGenerator.generate_docs? && (errs.any? || fails.any?)
-      write_caller!(test)
-      DocumentGenerator.register_test!(test)
-    end
-  end
-
-  def assert_parse(haml, &block)
-    haml = haml.unindent
-    ast  = block.call
-
-    expect(parse_string(haml)).to eq(ast)
-  end
-
-  def assert_compile(before, after)
-    result = described_class.new.call(before)
-    expect(result).to eq(after)
-  end
-
-  private
-
-  def write_caller!(test)
-    example = RSpec.current_example
-    test.lineno = example.metadata[:line_number]
-    test.dir, test.file = example.file_path.gsub(%r{^.+spec/hamlit/}, '').split('/')
-  end
-
-  def expect_compatibility(impl, test, options, type: :success)
-    case impl
-    when :haml
-      expect_haml(impl, test, options, type)
-    when :faml
-      expect_faml(impl, test, options, type)
-    end
-  end
-
-  def expect_haml(impl, test, options, type)
-    expect_implementation(impl, test, options, type) do |test, options|
-      options = DEFAULT_OPTIONS.merge(options)
-      Haml::Engine.new(test.src_haml, options).render(Object.new, {})
-    end
-  end
-
-  def expect_faml(impl, test, options, type)
-    expect_implementation(impl, test, options, type) do |test, options|
-      options = options.dup
-      options.delete(:escape_html)
-      eval Faml::Engine.new(options).call(test.src_haml)
-    end
-  end
-
-  def expect_implementation(impl, test, options, type, &block)
-    if type == :error
-      expect_any_error { block.call(test, options) }
-      begin
-        block.call(test, options)
-      rescue Exception => e
-        err = "#{e.class}: #{e.message}"
-        test.send(:"#{impl}_html=", err)
-      end
-      return
-    end
-
-    result = block.call(test, options)
-    test.send(:"#{impl}_html=", result)
-
-    case type
-    when :success
-      expect(test.hamlit_html).to eq(result)
-    when :failure
-      expect(test.hamlit_html).to_not eq(result)
-    end
-  end
-
-  def expect_any_error(&block)
-    origin = RSpec::Expectations.configuration.warn_about_potential_false_positives?
-    RSpec::Expectations.configuration.warn_about_potential_false_positives = false
-    expect { block.call(test, options) }.to raise_error
-  ensure
-    RSpec::Expectations.configuration.warn_about_potential_false_positives = origin
-  end
-
-  def array_wrap(arr)
-    return arr if arr.is_a?(Array)
-    [arr]
-  end
-
-  def tests
-    @tests ||= []
-  end
-end