syro-tilt 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0c344875f1c37067ea3ede68552941eda515bf0d3e0b66e9b3335c5e5b15900f
+  data.tar.gz: a2d4cec3221689f8b5f7c221c9e09f2e22f5c148266aacdb73c8cf41716e245d
+SHA512:
+  metadata.gz: 67f316b8d950eb1fcf8409883c47a000c1959c1ab208593681012d70b74642d6bce3b7df77e10bf6ff87975f121cb632da015704104c35774582a67df494e211
+  data.tar.gz: 03711476cdca8eb7867d3ab041e349f4d0cd57d464393753a46ab3319db766169054d97b4cefd694cca88f27a6e805b8747e8117724f987f78c27664a9ebbe7a

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/gems.locked
+/pkg/
+/spec/reports/
+/tmp/

data/.rubocop.yml

@@ -0,0 +1,60 @@
+# http://rubocop.readthedocs.io
+# https://github.com/bbatsov/rubocop/blob/master/config/enabled.yml
+AllCops:
+  DisplayCopNames: true
+  DisplayStyleGuide: true
+  ExtraDetails: true
+  TargetRubyVersion: 2.5
+
+
+Performance:
+  enabled: true
+
+Layout/AlignParameters:
+  EnforcedStyle: with_fixed_indentation
+
+Layout/EmptyLineAfterMagicComment:
+  Enabled: false
+
+Layout/IndentHash:
+  EnforcedStyle: consistent
+
+Layout/MultilineOperationIndentation:
+  EnforcedStyle: indented
+
+Layout/SpaceInsideStringInterpolation:
+  EnforcedStyle: space
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/LineLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Style/FormatStringToken:
+  Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/Next:
+  MinBodyLength: 8
+

data/Gemfile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Evan Lecklider
+
+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

@@ -0,0 +1,102 @@
+# Syro::Tilt
+
+Render [Tilt][tilt] templates in [Syro][syro] routes.
+
+
+## Usage
+
+An example Syro app using Syro::Tilt would look like this:
+
+```erb
+<%# 'html.html.erb' %>
+<% greeting = 'Hey there!' %>
+
+<p>
+  <%= greeting %>
+</p>
+```
+
+```ruby
+require 'syro'
+require 'syro/tilt'
+
+app = Syro.new do
+  get do
+    render 'home'
+  end
+end
+```
+
+Calling `render` will look for a template file (e.g. "views/home.html.erb"),
+render it in the context of the route, write the content to Syro's response, and
+set the `Content-Type` header based on the file extension (i.e. the ".html"
+means that it's a `text/html` response).
+
+
+## API
+
+`partial`: render a template from Tilt into a string, optionally passing in
+local variables and yielding to a block.
+
+`render`: render a Tilt template to a string (using `partial`), write the
+contents to Syro's response, and set the content type.
+
+`layout`: set (or get) a layout file to be used to wrap calls to `render`.
+
+`templates_directory`: the default directory to look for template files in.
+Overwriting this method is the recommended way to configure your template
+location. For example:
+
+```ruby
+def templates_directory
+  'app/views'
+end
+```
+
+`template_options`: a hash of options passed to `Tilt.new`. The class of the
+template being instantiated is passed so you can customize the options for each
+template engine. Overwriting this method is the recommended way to configure
+template options per engine. For example:
+
+```ruby
+def template_options(templ)
+  if templ == Hamlit::Block::Engine
+    { escape_html: true }
+  elsif templ == Tilt::ErubiTemplate
+    { engine_class: Erubi::CaptureEndEngine, escape: true, escape_capture: false, freeze: true, yield_returns_buffer: true }
+  else
+    {}
+  end
+end
+```
+
+`template`: create a new `Tilt` instance from a path to a template.
+
+`content_for`: capture content for use later.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'syro-tilt', require: 'syro/tilt'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install syro-tilt
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License][mit].
+
+
+[mit]: https://opensource.org/licenses/MIT
+[syro]: https://github.com/soveran/syro
+[tilt]: https://github.com/rtomayko/tilt

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/lib/syro/tilt.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+require 'syro'
+require 'tilt'
+
+class Syro # :nodoc:
+  # Render Tilt templates in Syro routes.
+  module Tilt
+    DEFAULT_MIME_TYPE = 'text/plain'
+    DOT = '.'
+    EMPTY = ''
+    HTTP_ACCEPT = 'HTTP_ACCEPT'
+    MIME_TYPE_ANY = '*/*'
+
+    ACCEPT_CAPTURE_QUALITY = /\Aq=([\d.]+)/.freeze
+    ACCEPT_SPLIT_MULTIPLES = /\s*,\s*/.freeze
+    ACCEPT_SPLIT_PARTS = /\s*;\s*/.freeze
+
+    # A Tilt template for the file path passed in.
+    #
+    # @return [Tilt::Template]
+    def template(path)
+      ::Tilt.new(path, template_options(::Tilt.template_for(path)))
+    end
+
+    # Options passed to Tilt.new.
+    #
+    # @param templ [Class]
+    #   The class of the template engine being used e.g. "Tilt::ErubiTemplate".
+    #
+    # @return [Hash]
+    def template_options(_templ = nil)
+      {}
+    end
+
+    # The default directory to look for templates within.
+    #
+    # @return [String]
+    def templates_directory
+      'views'
+    end
+
+    # Find a template's file path based on a "fuzzy" name like "posts/show". The
+    # HTTP Accept header will be checked and the first template found that
+    # matches the MIME type of the Accept header will be used, otherwise the
+    # first matching template file will be used.
+    #
+    # @param path [String]
+    #   A "fuzzy" file path like "posts/show".
+    # @param from [String]
+    #   The directory to look for templates within.
+    #
+    # @return [String]
+    #   The path to the template file.
+    def template_path(path, from = nil)
+      from ||= templates_directory
+      path = File.join(from, path)
+
+      accepts = env.fetch(HTTP_ACCEPT) { EMPTY }.to_s.then do |header|
+        # Taken from Rack::Request#parse_http_accept_header (which is a private
+        # method).
+        header.split(ACCEPT_SPLIT_MULTIPLES).map do |part|
+          attribute, parameters = part.split(ACCEPT_SPLIT_PARTS, 2)
+          quality = 1.0
+
+          if parameters && ACCEPT_CAPTURE_QUALITY.match?(parameters)
+            quality = ACCEPT_CAPTURE_QUALITY.match(parameters)[1].to_f
+          end
+
+          [attribute, quality]
+        end
+      end
+
+      # Reject "*/*" because it will always match the first thing it is compared
+      # to, regardless of wether there's a better match coming up.
+      accepts.reject! { |acc, _q| acc == MIME_TYPE_ANY }
+
+      # Find all potential templates e.g. ones with the same name but different
+      # template engines or MIME types.
+      potentials = Dir.glob(File.join(from, '**', '*')).filter do |potential|
+        potential.start_with?(path)
+      end.sort
+
+      # Select the best potential template match based on MIME type and HTTP
+      # Accept header.
+      potentials.find do |potential|
+        content_type = template_mime_type(potential)
+
+        accepts.any? do |acc, _quality|
+          Rack::Mime.match?(content_type, acc)
+        end
+      end || potentials.first
+    end
+
+    # Get the MIME type of a template file. The MIME type is looked up from
+    # Rack's MIME type list.
+    #
+    # @return [String]
+    def template_mime_type(path)
+      File.basename(path).split(DOT).reverse.map do |ext|
+        Rack::Mime::MIME_TYPES[".#{ ext.downcase }"]
+      end.compact.first || DEFAULT_MIME_TYPE
+    end
+
+    # Generate a string by rendering the Tilt template in the context of `self`
+    # with the locals that were passed in.
+    #
+    # @example
+    #   partial('posts/show') # => "OMG look at this page!"
+    #
+    # @param path [String]
+    #   The path to the view template you'd like to render.
+    # @param locals [Hash]
+    #   The local variables to pass to the template.
+    # @option locals [String] :from
+    #   The directory to look for templates within.
+    #
+    # @return [String]
+    def partial(path, locals = {})
+      template(template_path(path, locals.delete(:from))).render(self, locals) { yield if block_given? }
+    end
+
+    # Set or get the current layout. A layout is just another template to wrap
+    # other templates in. If set, it'll be used by #render.
+    #
+    # @param path [String]
+    #   A path to a template file.
+    #
+    # @return [String, nil]
+    def layout(templ = nil)
+      inbox[:tilt_layout] = templ if templ
+      inbox[:tilt_layout]
+    end
+
+    # Render a template to Syro's #res object and write the appropriate MIME
+    # type based on the rendered template.
+    #
+    # @param path [String]
+    #   The path to a view file.
+    # @param locals [Hash]
+    #   Local variables that should be accessible to the view.
+    # @option locals [String] :from
+    #   The directory to look for templates within.
+    def render(path, locals = {})
+      content = partial(path, locals.dup) { yield if block_given? }
+      content = partial(layout, locals.dup) { content } if layout
+
+      res.headers[Rack::CONTENT_TYPE] = template_mime_type(template_path(path, locals[:from]))
+      res.write content
+    end
+
+    # Capture content from a block for use later. Note that capturing the block
+    # is not implemented here due to the differences in varying template
+    # languages. Erubi::CaptureEndEngine and Hamlit::Block::Engine work well
+    # with this method.
+    #
+    # @param key [Symbol]
+    #   The content key name.
+    #
+    # @return [String]
+    #   An empty string if content is provided, otherwise the joined contents of
+    #   the provided key.
+    def content_for(key)
+      inbox[:tilt_content_for] ||= {}
+      inbox[:tilt_content_for][key] ||= []
+
+      if block_given?
+        inbox[:tilt_content_for][key].push yield
+
+        EMPTY # Returned to prevent the result of #push from displaying.
+      else
+        inbox[:tilt_content_for].delete(key).join
+      end
+    end
+
+    # Determine if there's content to display.
+    #
+    # @param key [Symbol]
+    #   The key to check for captured content for.
+    #
+    # @return [Boolean]
+    #   Have we captured any content for this key?
+    def content_for?(key)
+      inbox[:tilt_content_for] ||= {}
+      inbox[:tilt_content_for][key] ||= []
+
+      !inbox[:tilt_content_for][key].empty?
+    end
+  end
+
+  Deck.include Tilt
+end

data/syro-tilt.gemspec

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+Gem::Specification.new do |spec|
+  spec.name = 'syro-tilt'
+  spec.version = '0.1.0'
+  spec.authors = ['Evan Lecklider']
+  spec.email = ['evan@lecklider.com']
+  spec.summary = 'Render Tilt templates in Syro routes.'
+  spec.description = 'Render Tilt templates in Syro routes.'
+  spec.homepage = 'https://github.com/evanleck/syro-tilt'
+  spec.license = 'MIT'
+  spec.files = `git ls-files`.split("\n")
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'syro', '~> 3.0'
+  spec.add_dependency 'tilt', '~> 2.0'
+
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'rake', '~> 10.0'
+end

data/test/syro_tilt_test.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+require_relative '../lib/syro/tilt'
+require 'minitest/autorun'
+require 'syro'
+
+describe Syro::Tilt do
+  include Syro::Tilt
+
+  let(:inbox) do
+    {}
+  end
+
+  let(:templates_directory) do
+    'test/views'
+  end
+
+  let(:env) do
+    {}
+  end
+
+  describe '#template_path' do
+    it 'returns the path for an existing file' do
+      assert_equal 'test/views/plain.txt.erb', template_path('plain.txt.erb')
+    end
+
+    it 'finds the first match for an ambiguous file' do
+      assert_equal 'test/views/plain.txt.erb', template_path('plain')
+    end
+
+    it "returns nil for files that don't exist" do
+      assert_nil template_path('nah.txt')
+    end
+  end
+
+  describe '#layout' do
+    it 'is nil by default' do
+      assert_nil layout
+    end
+
+    it 'can be set' do
+      layout('something')
+
+      assert_equal 'something', layout
+    end
+  end
+
+  describe '#partial' do
+    it 'returns the contents of a template' do
+      assert_equal "Plain text.\n", partial('plain')
+    end
+
+    it 'accepts local variables' do
+      assert_equal "Locals rule!\n", partial('locals', what: 'rule')
+    end
+
+    it 'accepts a block' do
+      assert_equal "Layout!\n\nNot so plain!\n\n", partial('layout') { partial('notsoplain') }
+    end
+
+    describe 'template disambiguation' do
+      it 'picks the first one found without clear accepts' do
+        assert_equal "This is the first.\n", partial('typed')
+      end
+
+      describe 'disambiguation by HTTP Accept' do
+        let(:env) do
+          { 'HTTP_ACCEPT' => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8' }
+        end
+
+        it "checks the environment's 'Accept' header when present" do
+          assert_equal "This is HTML.\n", partial('typed')
+        end
+      end
+
+      describe 'disambiguation by HTTP Accept' do
+        let(:env) do
+          { 'HTTP_ACCEPT' => 'application/json' }
+        end
+
+        it "checks the environment's 'Accept' header when present" do
+          assert_equal %({ "thisis": "json" }\n), partial('typed')
+        end
+      end
+    end
+  end
+
+  describe '#render' do
+    let(:res) do
+      Syro::Response.new
+    end
+
+    it 'writes plain text to the response' do
+      render('plain')
+
+      assert_equal 'text/plain', res.headers['Content-Type']
+      assert_equal ["Plain text.\n"], res.body
+    end
+
+    it 'writes html text to the response' do
+      render('notsoplain')
+
+      assert_equal 'text/html', res.headers['Content-Type']
+      assert_equal ["Not so plain!\n"], res.body
+    end
+
+    it 'accepts local variables' do
+      render('locals', what: 'rule')
+
+      assert_equal ["Locals rule!\n"], res.body
+    end
+
+    it 'uses the layout when present' do
+      layout('layout')
+      render('notsoplain')
+
+      assert_equal ["Layout!\n\nNot so plain!\n\n"], res.body
+    end
+  end
+
+  describe '#content_for' do
+    it 'captures content from a block' do
+      content_for(:capture) do
+        'This is a capture.'
+      end
+
+      assert_equal 'This is a capture.', content_for(:capture)
+    end
+
+    it 'deletes content once output' do
+      content_for(:capture) do
+        'This is a capture.'
+      end
+
+      assert_equal 'This is a capture.', content_for(:capture)
+      assert_equal '', content_for(:capture)
+    end
+  end
+
+  describe '#content_for?' do
+    it 'reports captured content' do
+      content_for(:capture) do
+        'This is a capture.'
+      end
+
+      assert content_for?(:capture)
+      refute content_for?(:notthere)
+    end
+  end
+end

data/test/views/layout.erb

@@ -0,0 +1,3 @@
+Layout!
+
+<%= yield %>

data/test/views/locals.erb

@@ -0,0 +1 @@
+Locals <%= what %>!

data/test/views/notsoplain.html.erb

@@ -0,0 +1 @@
+Not so plain!

data/test/views/plain.txt.erb

@@ -0,0 +1 @@
+Plain text.

data/test/views/typed.anope.erb

@@ -0,0 +1 @@
+This is the first.

data/test/views/typed.html.erb

@@ -0,0 +1 @@
+This is HTML.

data/test/views/typed.json.erb

@@ -0,0 +1 @@
+{ "thisis": "json" }

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: syro-tilt
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Evan Lecklider
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: syro
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: tilt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !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'
+description: Render Tilt templates in Syro routes.
+email:
+- evan@lecklider.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/syro/tilt.rb
+- syro-tilt.gemspec
+- test/syro_tilt_test.rb
+- test/views/layout.erb
+- test/views/locals.erb
+- test/views/notsoplain.html.erb
+- test/views/plain.txt.erb
+- test/views/typed.anope.erb
+- test/views/typed.html.erb
+- test/views/typed.json.erb
+homepage: https://github.com/evanleck/syro-tilt
+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: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Render Tilt templates in Syro routes.
+test_files: []