seiten 0.0.6 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c07bb134e2faeb0ba5dd11af57a067fef28ceeb2
-  data.tar.gz: 94f0e43ea9839d4bf1598ef7c63e0c8bb39a590a
+SHA256:
+  metadata.gz: 3e17a2fa52d374492d7a6598c5e88c4d81935b091158a60bb14d298fd83469be
+  data.tar.gz: 4cb163a2fc0399bd5ab1267790907c6fb356f7d55996dd9b08c6a90c0a51166f
 SHA512:
-  metadata.gz: 341550a0f7cdd4b7e6a9a01b685c70796b6ec8007b13256482c5a028c95e0ada6d42e164994926c5cf4307d819d085944c10874e3e91ca2c9de95e10ef8defb6
-  data.tar.gz: 6657f6f1f45308fcab547c3dff423355c8ac887a154178a545230647829a824ace2361d921c3d94e6739288fe3a99a52a4b9f36d8ad586ebddd9f498b913bcbf
+  metadata.gz: 6d2e231683fa2bb4f8158211d8ab0b22f32093948792dce08e6dcff3011959deeaa61fc18d434a8dd73100b9e458dcb272a84c65fdd34d2c609b5442a03da8f9
+  data.tar.gz: a3f7f85d5196780920a259229c960d524176c127c102990c313ab161cdeb020f0f390e4a6130011528656562220f1ab5b34268507cf1ac9446c8602ade8bd281

data/Rakefile

@@ -26,6 +26,7 @@ Rake::TestTask.new(:test) do |t|
   t.libs << 'test'
   t.pattern = 'test/**/*_test.rb'
   t.verbose = false
+  t.warning = false
 end
 
 

data/app/controllers/seiten/pages_controller.rb

@@ -1,30 +1,9 @@
 module Seiten
   class PagesController < ::ApplicationController
+    include Seiten::Helpers::Backend
 
     def show
-      if current_page.nil?
-        raise ActionController::RoutingError.new("Page /#{params[:page]} not found")
-      else
-        @title = current_page.title
-
-        if params[:page]
-          filename = params[:page]
-        else
-          filename = Seiten.config[:root_page_filename]
-        end
-
-        if File.exists? Seiten::PageStore.current.file_path(filename: "#{filename}.html.erb", locale: I18n.locale)
-          file = Seiten::PageStore.current.file_path(filename: filename, locale: I18n.locale)
-        else
-          file = Seiten::PageStore.current.file_path(filename: filename)
-        end
-
-        if current_page.layout
-          render file: file, layout: current_page.layout
-        else
-          render file: file
-        end
-      end
+      render_seiten_page
     end
   end
 end

data/config/initializers/seiten.rb

@@ -1 +1 @@
-Seiten::PageStore.initialize_page_stores
+Seiten.initialize_navigations

data/lib/seiten/errors/base_error.rb

@@ -0,0 +1,4 @@
+module Seiten::Errors
+  class BaseError < StandardError
+  end
+end

data/lib/seiten/errors/page_error.rb

@@ -0,0 +1,4 @@
+module Seiten::Errors
+  class PageError < BaseError
+  end
+end

data/lib/seiten/errors/routing_error.rb

@@ -0,0 +1,4 @@
+module Seiten::Errors
+  class RoutingError < BaseError
+  end
+end

data/lib/seiten/helpers/backend.rb

@@ -0,0 +1,23 @@
+module Seiten
+  module Helpers
+    # Those helpers are convenience methods added to Seiten::PagesController or useful for building your own.
+    module Backend
+      extend ActiveSupport::Concern
+
+      def self.included(base)
+        base.prepend_view_path Seiten.config[:pages_dir]
+        base.before_action :raise_seiten_routing_error, unless: :current_page
+      end
+
+      private
+
+      def raise_seiten_routing_error
+        raise Seiten::Errors::RoutingError.new("Page /#{params[:slug]} not found")
+      end
+
+      def render_seiten_page
+        render current_page.template_path, layout: current_page.layout
+      end
+    end
+  end
+end

data/lib/seiten/helpers/current.rb

@@ -0,0 +1,33 @@
+module Seiten
+  module Helpers
+    # Those helpers are convenience methods added to ApplicationController.
+    module Current
+      extend ActiveSupport::Concern
+
+      included do
+        if respond_to?(:helper_method)
+          helper_method :current_navigation
+          helper_method :current_page
+        end
+      end
+
+      def current_navigation
+        @current_navigation ||= set_current_navigation
+      end
+
+      def current_page
+        @current_page ||= set_current_page
+      end
+
+      private
+
+      def set_current_navigation
+        Seiten::Navigation.find_by(name: params[:navigation_id] || 'application', locale: params[:locale] || I18n.locale.to_s)
+      end
+
+      def set_current_page
+        current_navigation&.pages&.find_by(slug: params[:slug]) if params[:slug]
+      end
+    end
+  end
+end

data/lib/seiten/helpers/frontend.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Seiten
+  module Helpers
+    module Frontend
+      def link_to_seiten_page(page)
+        link_to page.title, page.path
+      end
+
+      def seiten_navigation(navigation = current_navigation, parent_id: nil, deep: 2, html: {})
+        Seiten::HTML::Navigation.new(self, navigation: navigation, parent_id: parent_id, current_page: current_page, deep: deep, html: html).body
+      end
+
+      def seiten_breadcrumb(separator: '>', html: {})
+        Seiten::HTML::Breadcrumb.new(self, page: current_page, separator: separator, html: html).body
+      end
+    end
+  end
+end

data/lib/seiten/html/breadcrumb.rb

@@ -0,0 +1,41 @@
+module Seiten
+  module HTML
+    class Breadcrumb
+      attr_reader :body
+
+      def initialize(view_context, page:, separator: '>', html: {})
+        @view_context = view_context
+        @current_page = page
+        @separator = separator
+        @html_options = Seiten.config[:html].deep_merge(html || {})
+        @body = build_navigation if @current_page
+      end
+
+      private
+
+      def build_navigation
+        classes = Seiten::HTML::Helpers.build_classes(class_options: @html_options[:breadcrumb], modifier_options: @html_options[:modifier])
+        @view_context.content_tag(:ul, class: classes) do
+          pages = @current_page.breadcrumbs.each_with_index.map do |page, index|
+            build_page_element(page, index)
+          end
+          @view_context.safe_join(pages)
+        end
+      end
+
+      def build_page_element(page, index)
+        modifiers = page == @current_page ? [:current] : []
+        classes   = Seiten::HTML::Helpers.build_classes(:item, modifiers: modifiers, class_options: @html_options[:breadcrumb], modifier_options: @html_options[:modifier])
+
+        @view_context.content_tag :li, class: classes do
+          if @separator && index.positive?
+            sep_class = Seiten::HTML::Helpers.build_classes(:separator, class_options: @html_options[:breadcrumb])
+            span = @view_context.content_tag(:span, @separator, class: sep_class)
+          end
+          link = @view_context.link_to_seiten_page(page)
+          @view_context.safe_join([span, link])
+        end
+      end
+    end
+  end
+end

data/lib/seiten/html/helpers.rb

@@ -0,0 +1,32 @@
+module Seiten
+  module HTML
+    module Helpers
+      def self.build_page_modifiers(page, current_page)
+        modifiers = []
+        modifiers << :parent if page.children?
+        if page.active?(current_page)
+          modifiers << :active
+          modifiers << (page == current_page ? :current : :expanded)
+        end
+        modifiers
+      end
+
+      def self.build_classes(element = nil, class_options:, modifier_options: [], modifiers: [], merge: nil)
+        classes = []
+
+        klass = class_options[element || :base]
+        classes << klass
+
+        if modifiers.any?
+          base = (modifier_options[:base].presence || klass)
+          modifiers.each do |modifier|
+            classes << "#{base}#{modifier_options[:separator]}#{modifier_options[modifier]}"
+          end
+        end
+
+        classes << merge if merge
+        classes.join(' ')
+      end
+    end
+  end
+end

data/lib/seiten/html/navigation.rb

@@ -0,0 +1,39 @@
+module Seiten
+  module HTML
+    class Navigation
+      attr_reader :body
+
+      def initialize(view_context, navigation:, parent_id: nil, current_page: nil, deep: 2, html: {})
+        @view_context = view_context
+        @start_depth = deep
+        @html_options = Seiten.config[:html].deep_merge(html || {})
+        @current_page = current_page
+        @body = build_navigation(navigation, parent_id: parent_id, deep: deep)
+      end
+
+      private
+
+      def build_navigation(navigation, parent_id:, deep:)
+        wrapper_class = @start_depth != deep ? :nodes : nil
+
+        return unless deep.positive?
+
+        @view_context.content_tag(:ul, class: Seiten::HTML::Helpers.build_classes(wrapper_class, class_options: @html_options[:navigation], modifier_options: @html_options[:modifier])) do
+          pages = navigation.pages.where(parent_id: parent_id).map do |page|
+            children = build_navigation(navigation, parent_id: page.id, deep: deep - 1) if page.children?
+            build_page_element(page, children)
+          end
+          @view_context.safe_join(pages)
+        end
+      end
+
+      def build_page_element(page, children)
+        modifiers = Seiten::HTML::Helpers.build_page_modifiers(page, @current_page)
+        classes   = Seiten::HTML::Helpers.build_classes(:item, modifiers: modifiers, merge: page.html_options[:class], class_options: @html_options[:navigation], modifier_options: @html_options[:modifier])
+        @view_context.content_tag(:li, page.html_options.merge(class: classes)) do
+          @view_context.safe_join([@view_context.link_to_seiten_page(page), children])
+        end
+      end
+    end
+  end
+end

data/lib/seiten/navigation.rb

@@ -0,0 +1,43 @@
+module Seiten
+  class Navigation
+    attr_accessor :name, :locale, :config, :dir, :page_collection
+
+    def initialize(options={})
+      @name   = options[:name].to_s
+      @locale = options[:locale].to_s
+      @config = options[:config] || File.join(Rails.root, Seiten.config[:config_dir], "#{id}.yml")
+      @dir    = options[:dir]    || File.join(Rails.root, Seiten.config[:pages_dir], @name, @locale)
+      @page_collection = Seiten::PageCollection.new(navigation_id: id)
+    end
+
+    class << self
+      def find_by(params={})
+        where(params).first
+      end
+
+      def where(params={})
+        Seiten.navigations.select do |navigation|
+          params.all? do |param|
+            navigation.send(param[0]) == param[1]
+          end
+        end
+      end
+    end
+
+    def id
+      "%s.%s" % [name, locale]
+    end
+
+    def pages
+      page_collection
+    end
+
+    def pages=(pages_array)
+      page_collection.pages = pages_array.map { |page| page.navigation_id = id; page }
+      # return page_collection
+      # NOTE: This doesn't work and just returns page_array.
+      # I think because page_collection#pages= attr_accessor is called first
+      # and thus why our return call is ignored.
+    end
+  end
+end

data/lib/seiten/page.rb

@@ -1,63 +1,83 @@
-module Seiten
+# frozen_string_literal: true
 
+module Seiten
   class Page
-
-    attr_accessor :id, :parent_id, :title, :children, :slug, :redirect, :layout
+    attr_accessor :navigation_id, :id, :parent_id, :title, :slug, :refer, :data, :html_options
+    attr_writer :layout
 
     # initialize Page object with attributes
     def initialize(options={})
-      @id        = options[:id]
-      @parent_id = options[:parent_id]
-      @title     = options[:title]
-      @slug      = options[:slug]
-      @redirect  = options[:redirect]
-      @layout    = options[:layout]
+      @navigation_id  = options[:navigation_id]
+      @id             = options[:id]
+      @parent_id      = options[:parent_id]
+      @title          = options[:title]
+      @slug           = options[:slug]
+      @refer          = options[:refer]
+      @layout         = options[:layout]
+      @data           = options[:data].each_with_object({}){|(k,v), h| h[k.to_sym] = v} if options[:data]
+      @data         ||= {}
+      @html_options   = options[:html].each_with_object({}){|(k,v), h| h[k.to_sym] = v} if options[:html]
+      @html_options ||= {}
     end
 
-    class << self
+    def navigation
+      Seiten::Navigation.find_by(id: navigation_id)
+    end
 
-      def all
-        Seiten::PageStore.current.pages
-      end
+    # returns true if slug starts with http:// or https://
+    def external?
+      !!(slug.match(/^https?:\/\/.+/))
+    end
 
-      # find page by id
-      def find(id)
-        all.select { |page| page.id == id }.first
-      end
+    # get parent of page
+    def parent
+      navigation.pages.find(parent_id)
+    end
 
-      # find all pages by parent_id
-      def find_by_parent_id(parent_id)
-        all.select { |page| page.parent_id == parent_id }
-      end
+    def parent?
+      parent.present?
+    end
 
-      # find a page by slug
-      def find_by_slug(slug)
-        if slug
-          slug = slug[1..-1] if slug[0] == "/"
-        end
-        all.select { |page| page.slug == slug }.first
-      end
+    def ancestors
+      return @ancestors unless @ancestors.nil?
 
-      # get breadcrumb of given page (reversed)
-      def get_breadcrumb(page)
-        pages ||= []
-        pages << page
-        if page.parent
-          pages << get_breadcrumb(page.parent)
-        end
-        pages.flatten
+      @ancestors = []
+      return @ancestors unless parent?
+
+      ancestor = parent
+      loop do
+        @ancestors << ancestor
+        ancestor = ancestor.parent
+        break if ancestor.nil?
       end
 
+      @ancestors
     end
 
-    # get parent of page
-    def parent
-      Page.find(parent_id)
+    def self_and_ancestors
+      @self_and_ancestors ||= ancestors.insert(0, self)
+    end
+
+    def breadcrumbs
+      @breadcrumbs ||= self_and_ancestors.reverse
+    end
+
+    # get root page of current page branch
+    def root
+      if self.parent?
+        self.parent.root
+      else
+        self
+      end
     end
 
     # get children of page
     def children
-      Page.all.select { |page| page.parent_id == id }
+      navigation.pages.where(parent_id: id)
+    end
+
+    def children?
+      navigation.pages.find_by(parent_id: id).present?
     end
 
     # true if child is children of page
@@ -84,5 +104,27 @@ module Seiten
         end
       end
     end
+
+    def template_path
+      [
+        navigation_id.gsub(/\./, '/'),
+        slug.present? ? slug : Seiten.config[:root_page]
+      ].join('/')
+    end
+    alias_method :to_s, :template_path
+
+    def path
+      return refer if refer
+      return '#' if slug.nil?
+      return slug if external?
+
+      navigation_name = navigation.name == 'application' ? nil : navigation.name
+
+      [:seiten, navigation_name.try(:to_sym), :page, { slug: slug }]
+    end
+
+    def layout
+      @layout || Seiten.config[:default_layout]
+    end
   end
 end

data/lib/seiten/page_collection.rb

@@ -0,0 +1,54 @@
+module Seiten
+  class PageCollection
+    attr_accessor :navigation_id, :pages
+
+    def initialize(options = {})
+      @navigation_id = options[:navigation_id]
+      @pages         = options[:pages] || []
+    end
+
+    def navigation
+      Seiten::Navigation.find_by(id: navigation_id)
+    end
+
+    def build(options = {})
+      Seiten::PageCollectionBuilder.call(self, options)
+    end
+
+    def all
+      pages.to_a
+    end
+
+    def find(id)
+      find_by(id: id)
+    end
+
+    def find_by(params)
+      @find_by ||= {}
+      return @find_by[params] if @find_by.key?(params)
+
+      @find_by[params] = pages.find do |page|
+        params.all? do |k, v|
+          page.send(k) == v
+        end
+      end
+    end
+
+    def where(params)
+      @where ||= {}
+      return @where[params] if @where.key?(params)
+
+      @where[params] = pages.select do |page|
+        params.all? do |k, v|
+          page.send(k) == v
+        end
+      end
+    end
+
+    def new(params = {})
+      page = Seiten::Page.new(params.merge(navigation_id: navigation_id))
+      pages << page
+      page
+    end
+  end
+end

data/lib/seiten/page_collection_builder.rb

@@ -0,0 +1,63 @@
+module Seiten
+  class PageCollectionBuilder
+    def self.call(page_collection, options={})
+      pages      = options[:pages]
+      parent_id  = options[:parent_id] # || nil
+      layout     = options[:layout]
+      prefix_url = options[:prefix_url] || ""
+
+      @id ||= 1
+      @parsed_pages ||= []
+
+      pages.each_index do |i|
+
+        # Load page and set parent_id and generated page id
+        page = pages[i]
+        page["id"] = @id
+        page["parent_id"] = parent_id
+        page["layout"] ||= layout
+
+        # Increment generated id
+        @id += 1
+
+        # Build slug
+        raise Errors::PageError, "The `url` option can not be an external path. Use the `refer` option to link to external resources." if page["url"] && !!(page["url"].match(/^https?:\/\/.+/))
+        slug = Seiten::SlugBuilder.call(page, prefix_url) unless page['url'].is_a?(FalseClass)
+
+        # Set refer
+        if page["refer"]
+          if page["refer"].is_a?(TrueClass)
+            page["refer"] = "/" + Seiten::SlugBuilder.call(page["nodes"].first, page["slug"])
+          end
+          raise Errors::PageError, "The `refer` option must be `true` or an absolute or external path" if page["refer"] != true && page["refer"][0] != "/" && !(page["refer"].match(/^https?:\/\/.+/))
+        else
+          page["slug"] = slug
+        end
+
+        # Set layout
+        if page["layout"]
+          if page["layout"].is_a?(String)
+            inherited_layout = page["layout"]
+          elsif page["layout"].is_a?(Hash)
+            if page["layout"]["inherit"]
+              inherited_layout = page["layout"]
+            else
+              inherited_layout = nil
+            end
+            page["layout"] = page["layout"]["name"]
+          end
+        end
+
+        # Load children
+        if page["nodes"]
+          self.call(page_collection, pages: page["nodes"], parent_id: page["id"], prefix_url: slug, layout: inherited_layout, external: page["external"])
+        end
+
+        page_params = page.each_with_object({}){|(k,v), h| h[k.to_sym] = v}
+        @parsed_pages << page_collection.new(page_params)
+      end
+
+      @parsed_pages
+    end
+  end
+end

data/lib/seiten/railtie.rb

@@ -0,0 +1,7 @@
+module Seiten
+  class Railtie < Rails::Railtie
+    config.action_dispatch.rescue_responses.merge!(
+      'Seiten::Errors::RoutingError' => :not_found
+    )
+  end
+end

data/lib/seiten/routes_helper.rb

@@ -1,16 +1,21 @@
 class ActionDispatch::Routing::Mapper
+  def seiten(*resources)
+    options = resources.extract_options!
+    options[:to] ||= 'seiten/pages#show'
 
-  def seiten_resources
-    Seiten::PageStore.storages.each do |page_store|
-      page_store.pages.each do |page|
-        if page.redirect
-          get page.slug, to: redirect { |p, req|
-            Rails.application.routes.url_helpers.seiten_page_path(page: page.redirect, locale: p[:locale])
-          }
-        end
-      end
-    end
+    resources.each do |resource|
+      resource_options = options.dup
+
+      resource_options[:as] ||= resource == :application ? :seiten_page : "seiten_#{resource}_page"
+
+      resource_options[:defaults] ||= {}
+      resource_options[:defaults][:navigation_id] = resource.to_s unless resource == :application
+      resource_options[:defaults][:slug] = ''
 
-    get "(*page)" => "seiten/pages#show", as: :seiten_page
+      # NOTE: See https://github.com/rails/rails/issues/31228
+      resource_options[:constraints] ||= ->(req) { req.path.exclude? 'rails/active_storage' }
+
+      get '(*slug)', resource_options
+    end
   end
 end

data/lib/seiten/slug_builder.rb

@@ -0,0 +1,32 @@
+module Seiten
+  class SlugBuilder
+
+    def self.call(page_options, prefix_url='')
+      page_options = page_options.with_indifferent_access
+      title = page_options['title']
+      url   = page_options['url']
+      root  = page_options['root']
+
+      # if url is nil parameterize title otherwise just use url
+      slug = url.nil? ? title.parameterize : url
+
+      # prepend prefix_url if slug is not root or external url
+      unless slug[0] == "/" || !!(slug.match(/^https?:\/\/.+/)) || !prefix_url.present?
+        slug = "#{prefix_url}/#{slug}"
+      end
+
+      # return empty string if page slug is /
+      if slug == "/" || root == true
+        slug = ""
+      end
+
+      # remove leading slash if present
+      if slug
+        slug = slug[1..-1] if slug[0] == "/"
+      end
+
+      slug
+    end
+
+  end
+end

data/lib/seiten/version.rb

@@ -1,3 +1,3 @@
 module Seiten
-  VERSION = "0.0.6"
+  VERSION = "1.0.0"
 end