impression 0.1 → 0.5

data/test/test_app.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class AppTest < MiniTest::Test
+  def test_empty_app
+    app = Impression::App.new(path: '/')
+    req = mock_req(':method' => 'GET', ':path' => '/')
+
+    app.call(req)
+    assert_equal Qeweney::Status::NOT_FOUND, req.adapter.status
+  end
+
+  def test_app_each
+    app = Impression::App.new(path: '/')
+    
+    buffer = []
+    app.each { |r| buffer << r }
+    assert_equal [app], buffer
+
+    foo = PathRenderingResource.new(parent: app, path: 'foo')
+    bar = PathRenderingResource.new(parent: app, path: 'bar')
+    
+    buffer = []
+    app.each { |r| buffer << r }
+    assert_equal [app, foo, bar], buffer
+  end
+
+  def test_app_to_proc
+    app = Impression::App.new(path: '/')
+    app_proc = app.to_proc
+
+    foo = PathRenderingResource.new(parent: app, path: 'foo')
+    bar = PathRenderingResource.new(parent: app, path: 'bar')
+
+    # req = mock_req(':method' => 'GET', ':path' => '/')
+    # app_proc.(req)
+    # assert_equal Qeweney::Status::NOT_FOUND, req.adapter.status
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo')
+    app_proc.(req)
+    assert_equal '/foo', req.adapter.body
+
+    req = mock_req(':method' => 'GET', ':path' => '/bar')
+    app_proc.(req)
+    assert_equal '/bar', req.adapter.body
+
+    req = mock_req(':method' => 'GET', ':path' => '/baz')
+    app_proc.(req)
+    assert_equal Qeweney::Status::NOT_FOUND, req.adapter.status
+  end
+end

data/test/test_file_tree.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'qeweney/test_adapter'
+
+class FileTreeTest < MiniTest::Test
+  STATIC_PATH = File.join(__dir__, 'static')
+
+  def setup
+    @file_tree = Impression::FileTree.new(path: '/', directory: STATIC_PATH)
+  end
+
+  def test_file_tree_routing
+    req = mock_req(':method' => 'GET', ':path' => '/')
+    assert_equal @file_tree, @file_tree.route(req)
+
+    req = mock_req(':method' => 'GET', ':path' => '/nonexistent')
+    assert_equal @file_tree, @file_tree.route(req)
+
+    req = mock_req(':method' => 'GET', ':path' => '/index.html')
+    assert_equal @file_tree, @file_tree.route(req)
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo')
+    assert_equal @file_tree, @file_tree.route(req)
+  end
+
+  def static(path)
+    IO.read(File.join(STATIC_PATH, path))
+  end
+
+  def test_file_tree_response
+    req = mock_req(':method' => 'GET', ':path' => '/roo')
+    @file_tree.route_and_call(req)
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo2')
+    @file_tree.route_and_call(req)
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+    req = mock_req(':method' => 'GET', ':path' => '/bar2')
+    @file_tree.route_and_call(req)
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+    req = mock_req(':method' => 'GET', ':path' => '/js/a.js')
+    @file_tree.route_and_call(req)
+    assert_response static('js/a.js'), :js, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo.html')
+    @file_tree.route_and_call(req)
+    assert_response static('foo.html'), :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo')
+    @file_tree.route_and_call(req)
+    assert_response static('foo.html'), :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/index.html')
+    @file_tree.route_and_call(req)
+    assert_response static('index.html'), :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/')
+    @file_tree.route_and_call(req)
+    assert_response static('index.html'), :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/bar/index.html')
+    @file_tree.route_and_call(req)
+    assert_response static('bar/index.html'), :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/bar')
+    @file_tree.route_and_call(req)
+    assert_response static('bar/index.html'), :html, req
+  end
+
+  def test_non_root_file_tree_response
+    @file_tree = Impression::FileTree.new(path: '/app', directory: STATIC_PATH)
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/roo')
+    @file_tree.route_and_call(req)
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/foo2')
+    @file_tree.route_and_call(req)
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/bar2')
+    @file_tree.route_and_call(req)
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/js/a.js')
+    @file_tree.route_and_call(req)
+    assert_response static('js/a.js'), :js, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/foo.html')
+    @file_tree.route_and_call(req)
+    assert_response static('foo.html'), :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/foo')
+    @file_tree.route_and_call(req)
+    assert_response static('foo.html'), :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/index.html')
+    @file_tree.route_and_call(req)
+    assert_response static('index.html'), :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/')
+    @file_tree.route_and_call(req)
+    assert_response static('index.html'), :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/bar/index.html')
+    @file_tree.route_and_call(req)
+    assert_response static('bar/index.html'), :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/bar')
+    @file_tree.route_and_call(req)
+    assert_response static('bar/index.html'), :html, req
+  end
+end

data/test/test_file_watcher.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'fileutils'
+
+# class FileWatcherTest < MiniTest::Test
+#   def setup
+#     @tmp_path = File.expand_path('../tmp', __dir__)
+#     FileUtils.mkdir(@tmp_path)
+#   end
+
+#   def teardown
+#     FileUtils.rm_rf(@tmp_path)
+#   end
+
+#   def test_directory_watcher
+#     watcher = Impression::FileWatcher.new(@tmp_path)
+#     file_path = File.join(@tmp_path, 'foo')
+
+#     buffer = []
+#     spin do
+#       watcher.each { |kind, path| buffer << [kind, path] }
+#     end
+
+#     assert_equal [], buffer
+
+#     # create
+#     buffer.clear
+#     IO.write(file_path, 'bar')
+#     sleep 0.01
+#     assert_equal [[:create, file_path]], buffer
+
+#     # modify
+#     buffer.clear
+#     IO.write(file_path, 'baz')
+#     sleep 0.01
+#     assert_equal [[:modify, file_path]], buffer
+
+#     # move
+#     tmp_file_path = File.join("/tmp/#{rand(1024)}")
+#     file2_path = File.join(@tmp_path, 'foo2')
+#     buffer.clear
+#     IO.write(tmp_file_path, '---')
+#     FileUtils.mv(tmp_file_path, file2_path)
+#     sleep 0.01
+#     assert_equal [[:moved_to, file2_path]], buffer
+
+#     # delete
+#     buffer.clear
+#     FileUtils.rm(file_path)
+#     sleep 0.01
+#     assert_equal [[:delete, file_path]], buffer
+#   end
+
+#   def test_recursive_directory_watcher
+#   end
+# end

data/test/test_jamstack.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'qeweney/test_adapter'
+
+class JamstackTest < MiniTest::Test
+  JAMSTACK_PATH = File.join(__dir__, 'jamstack')
+
+  def setup
+    @jamstack = Impression::Jamstack.new(path: '/', directory: JAMSTACK_PATH)
+  end
+
+  def test_jamstack_routing
+    req = mock_req(':method' => 'GET', ':path' => '/')
+    assert_equal @jamstack, @jamstack.route(req)
+
+    req = mock_req(':method' => 'GET', ':path' => '/nonexistent')
+    assert_equal @jamstack, @jamstack.route(req)
+
+    req = mock_req(':method' => 'GET', ':path' => '/index.html')
+    assert_equal @jamstack, @jamstack.route(req)
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo')
+    assert_equal @jamstack, @jamstack.route(req)
+  end
+
+  def static(path)
+    IO.read(File.join(JAMSTACK_PATH, path))
+  end
+
+  def test_jamstack_response
+    req = mock_req(':method' => 'GET', ':path' => '/roo')
+    @jamstack.route_and_call(req)
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo2')
+    @jamstack.route_and_call(req)
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+    req = mock_req(':method' => 'GET', ':path' => '/bar2')
+    @jamstack.route_and_call(req)
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+    req = mock_req(':method' => 'GET', ':path' => '/assets/js/a.js')
+    @jamstack.route_and_call(req)
+    assert_response static('assets/js/a.js'), :js, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo')
+    @jamstack.route_and_call(req)
+
+    foo = H {
+      html5 {
+        head {
+          title 'Foo title'
+        }
+        body {
+          h1 'foo'
+        }
+      }
+    }
+    assert_response foo.render, :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/index')
+    @jamstack.route_and_call(req)
+
+    index = H {
+      html5 {
+        head {
+          title 'Hello'
+        }
+        body {
+          h1 'Index'
+        }
+      }
+    }
+    assert_response index.render, :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/')
+    @jamstack.route_and_call(req)
+    assert_response index.render, :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/bar')
+    @jamstack.route_and_call(req)
+    assert_response static('bar.html'), :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/baz')
+    @jamstack.route_and_call(req)
+
+    baz_index = H {
+      html5 {
+        head {
+          title 'BarBar'
+        }
+        body {
+          h1 'BarIndex'
+        }
+      }
+    }
+    assert_response baz_index.render, :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/articles/a')
+    @jamstack.route_and_call(req)
+
+    a = H {
+      html5 {
+        head {
+          title 'AAA'
+        }
+        body {
+          article {
+            h2 'BBB', id: 'bbb'
+          }
+        }
+      }
+    }
+    assert_response a.render, :html, req
+  end
+
+  def test_non_root_jamstack_response
+    @jamstack = Impression::Jamstack.new(path: '/app', directory: JAMSTACK_PATH)
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/roo')
+    @jamstack.route_and_call(req)
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/foo2')
+    @jamstack.route_and_call(req)
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/bar2')
+    @jamstack.route_and_call(req)
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/assets/js/a.js')
+    @jamstack.route_and_call(req)
+    assert_response static('assets/js/a.js'), :js, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/foo')
+    @jamstack.route_and_call(req)
+
+    foo = H {
+      html5 {
+        head {
+          title 'Foo title'
+        }
+        body {
+          h1 'foo'
+        }
+      }
+    }
+    assert_response foo.render, :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/index')
+    @jamstack.route_and_call(req)
+
+    index = H {
+      html5 {
+        head {
+          title 'Hello'
+        }
+        body {
+          h1 'Index'
+        }
+      }
+    }
+    assert_response index.render, :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/')
+    @jamstack.route_and_call(req)
+    assert_response index.render, :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/bar')
+    @jamstack.route_and_call(req)
+    assert_response static('bar.html'), :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/baz')
+    @jamstack.route_and_call(req)
+
+    baz_index = H {
+      html5 {
+        head {
+          title 'BarBar'
+        }
+        body {
+          h1 'BarIndex'
+        }
+      }
+    }
+    assert_response baz_index.render, :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/articles/a')
+    @jamstack.route_and_call(req)
+
+    a = H {
+      html5 {
+        head {
+          title 'AAA'
+        }
+        body {
+          article {
+            h2 'BBB', id: 'bbb'
+          }
+        }
+      }
+    }
+    assert_response a.render, :html, req
+  end
+
+  def test_page_list
+    @jamstack = Impression::Jamstack.new(path: '/app', directory: JAMSTACK_PATH)
+
+    list = @jamstack.page_list('/')
+    assert_equal [
+      { path: File.join(JAMSTACK_PATH, 'bar.html'), url: '/app/bar' },
+      { path: File.join(JAMSTACK_PATH, 'index.md'), title: 'Hello', url: '/app/index' },
+    ], list
+
+
+    list = @jamstack.page_list('/articles')
+    assert_equal [
+      {
+        path: File.join(JAMSTACK_PATH, 'articles/2008-06-14-manu.md'),
+        url: '/app/articles/2008-06-14-manu',
+        title: 'MMM',
+        layout: 'article',
+        date: Date.new(2008, 06, 14)
+      },
+      {
+        path: File.join(JAMSTACK_PATH, 'articles/2009-06-12-noatche.md'),
+        url: '/app/articles/2009-06-12-noatche',
+        title: 'NNN',
+        layout: 'article',
+        date: Date.new(2009, 06, 12)
+      },
+      { 
+        path: File.join(JAMSTACK_PATH, 'articles/a.md'),
+        url: '/app/articles/a',
+        title: 'AAA',
+        layout: 'article'
+      },
+    ], list
+  end
+
+  def test_template_resource_and_request
+    req = mock_req(':method' => 'GET', ':path' => '/foobar?q=42')
+    @jamstack.route_and_call(req)
+  
+    foo = H {
+      html5 {
+        head {
+          title 'Foobar'
+        }
+        body {
+          h1 '42'
+          a 'MMM', href: '/articles/2008-06-14-manu'
+          a 'NNN', href: '/articles/2009-06-12-noatche'
+          a 'AAA', href: '/articles/a'
+        }
+      }
+    }
+    assert_response foo.render, :html, req
+  end
+end

data/test/test_resource.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class ResourceTest < MiniTest::Test
+  def test_absolute_path
+    r1 = Impression::Resource.new(path: 'foo')
+    assert_equal '/foo', r1.absolute_path
+
+    r2 = Impression::Resource.new(parent: r1, path: 'bar')
+    assert_equal '/foo/bar', r2.absolute_path
+  end
+
+  def test_each
+    r1 = Impression::Resource.new(path: 'foo')
+    r2 = Impression::Resource.new(parent: r1, path: 'bar')
+    r3 = Impression::Resource.new(parent: r1, path: 'baz')
+
+    assert_equal [r2, r3], r1.children.values
+
+    buffer = []
+    r1.each { |r| buffer << r }
+    assert_equal [r1, r2, r3], buffer
+  end
+
+  def test_route
+    r1 = Impression::Resource.new(path: 'foo')
+    r2 = Impression::Resource.new(parent: r1, path: 'bar')
+    r3 = Impression::Resource.new(parent: r1, path: 'baz')
+    r4 = Impression::Resource.new(parent: r2, path: 'littlebar')
+
+    assert_equal [r2, r3], r1.children.values
+    assert_equal [r4], r2.children.values
+
+    req = mock_req(':method' => 'GET', ':path' => '/')
+    assert_nil r1.route(req)
+    assert_equal '/', req.resource_relative_path
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo2')
+    assert_nil r1.route(req)
+    assert_equal '/foo2', req.resource_relative_path
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo')
+    assert_equal r1, r1.route(req)
+    assert_equal '/', req.resource_relative_path
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo/bar')
+    assert_equal r2, r1.route(req)
+    assert_equal '/', req.resource_relative_path
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo/baz')
+    assert_equal r3, r1.route(req)
+    assert_equal '/', req.resource_relative_path
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo/bar/littlebar')
+    assert_equal r4, r1.route(req)
+    assert_equal '/', req.resource_relative_path
+  
+    req = mock_req(':method' => 'GET', ':path' => '/foo/bar/littlebar/littlebaz')
+    assert_equal r4, r1.route(req)
+    assert_equal '/littlebaz', req.resource_relative_path
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo/hi')
+    assert_equal r1, r1.route(req)
+    assert_equal '/hi', req.resource_relative_path
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo/hi/bye')
+    assert_equal r1, r1.route(req)
+    assert_equal '/hi/bye', req.resource_relative_path
+  end
+
+  def test_nested_resource_rendering
+    r1 = Impression::Resource.new(path: 'foo')
+    r2 = PathRenderingResource.new(parent: r1, path: 'bar')
+    r3 = PathRenderingResource.new(parent: r1, path: 'baz')
+
+    req = mock_req(':method' => 'GET', ':path' => '/')
+    assert_nil r1.route(req)
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo')
+    r1.route_and_call(req)
+    # default reply
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo/bar')
+    r1.route_and_call(req)
+    assert_equal '/foo/bar', req.response_body
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo/baz')
+    r1.route_and_call(req)
+    assert_equal '/foo/baz', req.response_body
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo/bbb')
+    assert_equal r1, r1.route(req)
+  end
+
+  def test_relative_path
+    r1 = CompletePathInfoRenderingResource.new(path: 'foo')
+    r2 = CompletePathInfoRenderingResource.new(parent: r1, path: 'bar')
+    r3 = CompletePathInfoRenderingResource.new(parent: r1, path: 'baz')
+
+    req = mock_req(':method' => 'GET', ':path' => '/')
+    assert_nil r1.route(req)
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo')
+    r1.route_and_call(req)
+    assert_equal '/foo /', req.response_body
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo/zzz')
+    r1.route_and_call(req)
+    assert_equal '/foo /zzz', req.response_body
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo/bar')
+    r1.route_and_call(req)
+    assert_equal '/foo/bar /', req.response_body
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo/bar/zzz')
+    r1.route_and_call(req)
+    assert_equal '/foo/bar /zzz', req.response_body
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo/baz')
+    r1.route_and_call(req)
+    assert_equal '/foo/baz /', req.response_body
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo/baz/xxx/yyy')
+    r1.route_and_call(req)
+    assert_equal '/foo/baz /xxx/yyy', req.response_body
+  end
+
+  class CallableResource < Impression::Resource
+    def initialize(**props, &block)
+      super(**props)
+      @block = block
+    end
+
+    def call(req)
+      @block.call(req)
+    end
+  end
+
+  def test_callable_resource
+    r1 = CompletePathInfoRenderingResource.new(path: 'foo')
+    r2 = CallableResource.new(parent: r1, path: 'bar') { |req| req.respond('hi') }
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo/bar')
+    r1.route_and_call(req)
+    assert_equal 'hi', req.response_body
+  end
+
+  class CallableRouteResource < Impression::Resource
+    def initialize(**props, &block)
+      super(**props)
+      @block = block
+    end
+
+    def route(req)
+      @block
+    end
+  end
+
+  def test_callable_from_route_method
+    r1 = CompletePathInfoRenderingResource.new(path: 'foo')
+    r2 = CallableRouteResource.new(parent: r1, path: 'bar') { |req| req.respond('bye') }
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo/bar')
+    r1.route_and_call(req)
+    assert_equal 'bye', req.response_body
+  end
+
+  def test_text_response
+    c = Class.new(Impression::Resource) do
+      def route(req)
+        case req.path
+        when '/text'
+          text_response('foo')
+        when '/html'
+          html_response('bar')
+        when '/json'
+          json_response({ :baz => 123 })
+        end
+      end
+    end
+
+    r = c.new(path: '/')
+
+    req = mock_req(':method' => 'GET', ':path' => '/text')
+    r.route_and_call(req)
+    assert_equal 'foo', req.response_body
+    assert_equal 'text/plain', req.response_content_type
+
+    req = mock_req(':method' => 'GET', ':path' => '/html')
+    r.route_and_call(req)
+    assert_equal 'bar', req.response_body
+    assert_equal 'text/html', req.response_content_type
+
+    req = mock_req(':method' => 'GET', ':path' => '/json')
+    r.route_and_call(req)
+    assert_equal '{"baz":123}', req.response_body
+    assert_equal 'application/json', req.response_content_type
+  end
+end