matestack-ui-core 0.7.2.1 → 1.0.0.rc.1

data/app/concepts/matestack/ui/core/wbr/wbr.haml

@@ -0,0 +1 @@
+%wbr{@tag_attributes}

data/app/concepts/matestack/ui/core/wbr/wbr.rb

@@ -0,0 +1,4 @@
+module Matestack::Ui::Core::Wbr
+  class Wbr < Matestack::Ui::Core::Component::Static
+  end
+end

data/app/concepts/matestack/ui/core/youtube/youtube.rb

@@ -1,7 +1,7 @@
 module Matestack::Ui::Core::Youtube
   class Youtube < Matestack::Ui::Core::Component::Static
 
-    REQUIRED_KEYS = [:yt_id, :height, :width]
+    requires :yt_id, :height, :width
 
     def setup
       url = 'https://www.youtube.com/embed/'

data/app/helpers/matestack/ui/core/application_helper.rb

@@ -1,34 +1,106 @@
 module Matestack
   module Ui
     module Core
+      # We're called ApplicationHelper but all we do so far is rendering.
       module ApplicationHelper
 
-        def render_page(page_class, only_page=false)
-          page_class.new(nil, context: {
-            params: params,
-            request: request
-          }, controller_instance: self).call(:show, nil, only_page)
+        # Allow the definition of a controller wide get_matestack_app_class
+        #
+        #     class SomeController < ActionController::Base
+        #       matestack_app MyAppClass
+        #       #...
+        #     end
+        #
+        def self.included(base)
+          base.extend(ClassMethods)
         end
+        module ClassMethods
+          def matestack_app _class
+            @matestack_app_class = _class
+          end
+
+          def get_matestack_app_class
+            if defined?(@matestack_app_class)
+              @matestack_app_class
+            else
+              nil
+            end
+          end
 
-        def render_component(page_class, component_key)
-          page_class.new(nil, context: {
-            params: params,
-            request: request
-          }, controller_instance: self).call(:show, component_key)
         end
 
-        def responder_for(page_class, options = {})
-          unless params[:component_key].blank?
-            render plain: render_component(page_class, params[:component_key])
-            return
+        # Matestack allows you to use `render` to render matestack pages.
+        #
+        #     render Pages::Member::Bookings::Index
+        #     render matestack: Pages::Member::Bookings::Index
+        #
+        def render(*args)
+          if (matestack_class = args.first).is_a?(Class) && (matestack_class < Matestack::Ui::Page)
+            options_hash = args[1].is_a?(Hash) ? args[1] : {}
+            Rendering::MainRenderer.render(self, matestack_class, options_hash)
+          elsif (options = args.first).is_a?(Hash) &&
+                  (matestack_arg = options[:matestack]) &&
+                  matestack_arg.is_a?(Class) &&
+                  (matestack_arg < Matestack::Ui::Page)
+            Rendering::MainRenderer.render(self, matestack_arg, options)
+          else
+            if params[:component_class].present? && !((options = args.first).is_a?(Hash) && options[:html].present?)
+              Rendering::MainRenderer.render(self, Matestack::Ui::Page, {})
+            else
+              super
+            end
           end
-          if params[:only_page]
-            render html: render_page(page_class, true)
+        end
+
+        # TODO: maybe/Axe remove this?
+        # Matestack allows implicit rendering. The matestack page class name is inferred from the
+        # controller path and action name.
+        #
+        #     class Clients::BookingsController < ApplicationController
+        #       def index
+        #         @bookings = Booking.all
+        #         # looks for Pages::Clients::Bookings::Index
+        #       end
+        #
+        #       def show
+        #         @booking = Booking.find params[:id]
+        #         # looks for Pages::Clients::Bookings::Show
+        #       end
+        #     end
+        #
+        # In this example, `clients/bookings#index` will render `Pages::Clients::Bookings::Index`,
+        # `clients/bookings#show` will render `Pages::Clients::Bookings::Show`.
+        #
+        # Custom action names translate also into page names.
+        #
+        #     class Clients::BookingsController < ApplicationController
+        #       def step1
+        #         # looks for Pages::Clients::Bookings::Step1
+        #       end
+        #     end
+        #
+        # In this example, the `clients/bookings#step1` action will render
+        # `Pages::Clients::Bookings::Step1`.
+        #
+        def default_render(*args)
+          matestack_page_class =
+            Rendering::DefaultRendererClassDeterminer.determine_class(controller_path, action_name)
+          if matestack_page_class
+            render matestack_page_class
           else
-            render html: render_page(page_class), layout: true
+            super
           end
         end
 
+        # Kept around for compatibility. Probably worth removing.
+        def responder_for(*args)
+          render(*args)
+        end
+
+        def matestack_component(component, options = {}, &block)
+          context = (options[:matestack_context] ||= {}).merge(controller: @_controller)
+          Matestack::Ui::Core::Component::Base.new(options.merge(matestack_context: context)).send(component, options.merge(matestack_context: context), &block)
+        end
       end
     end
   end

data/app/javascript/matestack-ui-core/index.js

@@ -0,0 +1,22 @@
+import Vue from 'vue/dist/vue.esm'
+import Vuex from 'vuex'
+import axios from 'axios'
+
+// Import from app/concepts/matestack/ui/core:
+import matestackEventHub from '../../../app/concepts/matestack/ui/core/js/event-hub'
+import componentMixin from '../../../app/concepts/matestack/ui/core/component/component'
+import matestackUiCore from '../../../app/concepts/matestack/ui/core/js/core'
+
+import styles from './styles/index.scss'
+
+const MatestackUiCore = {
+  Vue,
+  Vuex,
+  axios,
+  matestackEventHub,
+  componentMixin
+}
+
+window.MatestackUiCore = MatestackUiCore
+
+export default MatestackUiCore

data/app/javascript/matestack-ui-core/styles/index.scss

@@ -0,0 +1,5 @@
+// glob imports are not supported out of the box.
+// 
+// @import "../../../concepts/matestack/ui/core/**/*.scss";
+// @import "../../../concepts/matestack/ui/core/**/*.sass";
+// @import "../../../concepts/matestack/ui/core/**/*.css";

data/app/javascript/packs/matestack-ui-core.js

@@ -0,0 +1,8 @@
+// // Add polyfills for the asset pipeline
+// // https://github.com/matestack/matestack-ui-core/issues/238#issuecomment-583905838
+//
+// import 'core-js/stable'
+// import 'regenerator-runtime/runtime'
+
+import '../matestack-ui-core/index'
+export default MatestackUiCore

data/app/lib/matestack/ui/component.rb

@@ -0,0 +1 @@
+Matestack::Ui::Component = Matestack::Ui::Core::Component::Static

data/app/lib/matestack/ui/core/has_view_context.rb

@@ -0,0 +1,14 @@
+module Matestack::Ui::Core::HasViewContext
+  def initialize(*args)
+    super
+    @view_context = @options.dig(:context, :view_context)
+  end
+
+  def method_missing(*args, &block)
+    if @view_context.respond_to? args.first
+      @view_context.send(*args, &block)
+    else
+      raise NameError, "NameError: undefined method or local variable `#{args.first}' for #{self.class.name}"
+    end
+  end
+end

data/app/lib/matestack/ui/core/html_attributes.rb

@@ -0,0 +1,43 @@
+module Matestack::Ui::Core::HtmlAttributes
+
+  HTML_GLOBAL_ATTRIBUTES = [
+    :accesskey, :class, :contenteditable, :data, :dir, :draggable, 
+    :hidden, :id, :lang, :spellcheck, :style, :tabindex, :title, :translate
+  ]
+
+  HTML_EVENT_ATTRIBUTES = [
+    :onafterprint, :onbeforeprint, :onbeforeunload, :onerror, :onhashchange, :onload, :onmessage, 
+    :onoffline, :ononline, :onpagehide, :onpageshow, :onpopstate, :onresize, :onstorage, :onunload
+  ]
+
+  # prepend the initializer and add class methods
+  def self.included(base)
+    base.class_eval do
+      extend ClassMethods
+    end
+  end
+
+  module ClassMethods
+
+    def inherited(subclass)
+      subclass.html_attributes *self.allowed_html_attributes
+    end
+
+    def html_attributes(*attributes)
+      attributes.each do |attribute|
+        allowed_html_attributes.push(attribute)
+      end
+    end
+
+    def allowed_html_attributes
+      @allowed_html_attributes.flatten!&.uniq! if defined? @allowed_html_attributes
+      @allowed_html_attributes ||= []
+    end
+
+  end
+
+  def html_attributes
+    options.slice(*self.class.allowed_html_attributes).merge((options[:attributes] || {}))
+  end
+
+end

data/app/lib/matestack/ui/core/properties.rb

@@ -0,0 +1,88 @@
+module Matestack::Ui::Core::Properties
+
+  class PropertyMissingException < StandardError
+  end
+
+  class PropertyOverwritingExistingMethodException < StandardError
+  end
+
+  # prepend the initializer and add class methods
+  def self.included(base)
+    base.class_eval do
+      extend ClassMethods
+    end
+    base.send :prepend, Initializer
+  end
+  
+  # initializer calls super and creates instance methods for defined required and optional properties afterwards
+  module Initializer
+    def initialize(model=nil, options={})
+      options = model.dup if options.empty? && model.is_a?(Hash)
+      required_hooks(options)
+      optional_hooks(options)
+      super
+    end
+  end
+  
+  module ClassMethods
+    # define optinoal properties for custom components with `optional :foo, :bar`
+    def optional(*properties)
+      add_properties_to_list(optional_properties, properties)
+    end
+  
+    # define required properties for custom components with `requires :title, :foo, :bar`
+    def requires(*properties)
+      add_properties_to_list(requires_properties, properties)
+    end
+
+    def add_properties_to_list(list, properties)
+      properties.each do |property| 
+        if property.is_a? Hash 
+          property.each { |tmp_property| list.push(tmp_property) }
+        else
+          list.push(property) 
+        end
+      end
+    end
+  
+    # array of properties created from the component
+    def optional_properties
+      @component_properties ||= []
+    end
+  
+    # array of required properties from the component
+    def requires_properties
+      @requires_properties ||= []
+    end
+  end
+
+  def optional_hooks(options)
+    self.class.optional_properties.compact.each do |prop|
+      if prop.is_a? Array
+        hash = prop.flatten
+        options[hash.last[:as]] = options[hash.first]
+        prop = hash.last[:as]
+      end
+      raise PropertyOverwritingExistingMethodException, "Optional property #{prop} would overwrite already defined instance method for #{self.class}" if self.respond_to? prop
+      send(:define_singleton_method, prop) do 
+        options[prop]
+      end
+    end
+  end
+
+  def required_hooks(options)
+    self.class.requires_properties.compact.each do |prop|
+      if prop.is_a? Array
+        hash = prop.flatten
+        options[hash.last[:as]] = options[hash.first]
+        prop = hash.last[:as]
+      end
+      raise PropertyMissingException, "Required property #{prop} is missing for #{self.class}" if options[prop].nil?
+      raise PropertyOverwritingExistingMethodException, "Required property #{prop} would overwrite already defined instance method for #{self.class}" if self.respond_to? prop
+      send(:define_singleton_method, prop) do
+        options[prop]
+      end
+    end
+  end
+
+end

data/app/lib/matestack/ui/core/rendering/default_renderer_class_determiner.rb

@@ -0,0 +1,33 @@
+# Handles the default rendering mechanism
+#
+# Not really compatible with the new flexible naming schemes
+module Matestack::Ui::Core::Rendering::DefaultRendererClassDeterminer
+  module_function
+
+  def determine_class(controller_path, action_name)
+    possible_default_render_matestack_page_class_names(controller_path, action_name).each do |class_name|
+      begin
+        return matestack_class = class_name.constantize
+      rescue NameError
+      end
+    end
+    return nil
+  end
+
+  def possible_default_render_matestack_page_class_names(controller_path, action_name)
+    possible_default_render_matestack_page_paths(controller_path, action_name).collect { |page_path|
+      page_path.split("/").collect { |str| str.camelcase }.join("::")
+    }
+  end
+
+  def possible_default_render_matestack_page_paths(controller_path, action_name)
+    paths = []
+    paths << "pages/#{controller_path}/#{action_name}"
+    paths << "pages/#{controller_path}" if action_name == "index"
+    paths << "pages/#{controller_path.singularize}" if action_name == "show"
+    paths << "#{controller_path}/#{action_name}_page"
+    paths << "#{controller_path}_page" if action_name == "index"
+    paths << "#{controller_path.singularize}_page" if action_name == "show"
+    paths
+  end
+end

data/app/lib/matestack/ui/core/rendering/main_renderer.rb

@@ -0,0 +1,199 @@
+# The main renderer that is usually called to determine how to perform rendering
+module Matestack::Ui::Core::Rendering::MainRenderer
+  module_function
+
+  EMPTY_JSON = "{}"
+
+  # Instead of rendering without an app class, we always have an "empty" app class
+  # to fall back to
+  DEFAULT_APP_CLASS = Matestack::Ui::Core::App::App
+
+  def render(controller_instance, page_class, options)
+    app_class = resolve_app_class(controller_instance, options)
+
+    params = controller_instance.params
+
+    context = create_context_hash(controller_instance)
+
+    if params[:only_page]
+      # standalone page rendering, used when performing a transition
+      page_instance = page_class.new(controller_instance: controller_instance, context: context)
+      render_matestack_object(controller_instance, page_instance)
+    elsif (params[:component_key].present? && params[:component_class].blank?)
+      # async component rerendering from non isolated context
+      component_key = params[:component_key]
+      page_instance = page_class.new(controller_instance: controller_instance, context: context)
+      render_component(component_key, page_instance, controller_instance, context)
+    elsif (params[:component_class].present? && params[:component_key].blank?)
+      # isolated component rendering
+      component_class = params[:component_class]
+      page_instance = page_class.new(controller_instance: controller_instance, context: context)
+      public_options = JSON.parse(params[:public_options]).with_indifferent_access rescue nil
+      render_isolated_component(component_class, page_instance, controller_instance, context, public_options)
+    elsif (params[:component_class].present? && params[:component_key].present?)
+      # async component rerendering from isolated context
+      component_class_name = params[:component_class]
+      component_key = params[:component_key]
+      page_instance = page_class.new(controller_instance: controller_instance, context: context)
+      if params[:public_options].present?
+        public_options = JSON.parse(params[:public_options]).with_indifferent_access
+      else
+        public_options = nil
+      end
+      component_class = resolve_isolated_component(component_class_name)
+      if component_class
+        component_instance = component_class.new(public_options: public_options, context: context)
+        if component_instance.authorized?
+          render_component(component_key, component_instance, controller_instance, context)
+        else
+          raise "not authorized"
+        end
+      end
+    else
+      if app_class == false
+        page_instance = page_class.new(controller_instance: controller_instance, context: context)
+        render_matestack_object(controller_instance, page_instance, layout: true)
+      else
+        app_instance = app_class.new(page_class, controller_instance, context)
+        render_matestack_object(controller_instance, app_instance, layout: true)
+      end
+    end
+  end
+
+  def create_context_hash(controller_instance)
+    {
+      view_context: controller_instance.view_context,
+      params: controller_instance.params,
+      request: controller_instance.request
+    }
+  end
+
+  def render_matestack_object(controller_instance, object, opts = {}, render_method = :show)
+    object.prepare
+    object.response if object.respond_to? :response
+    rendering_options = {html: object.call(render_method)}.merge!(opts)
+    controller_instance.render rendering_options
+  end
+
+  def render_component(component_key, page_instance, controller_instance, context)
+    matched_component = nil
+
+    page_instance.matestack_set_skip_defer(false)
+
+    page_instance.prepare
+    page_instance.response
+
+    matched_component = dig_for_component(component_key, page_instance)
+
+    unless matched_component.nil?
+      render_matestack_object(controller_instance, matched_component, {}, :render_content)
+    else
+      # some 404 probably
+      raise Exception, "Async component with id #{component_key} could not be found while rerendering."
+    end
+  rescue Exception => e
+     Rails.logger.warn e
+     render json: {}, status: :not_found
+  end
+
+  def dig_for_component component_key, component_instance
+    matched_component = nil
+
+    component_instance.children.each do |child|
+      if child.respond_to?(:get_component_key)
+        if child.get_component_key == component_key
+          matched_component = child
+        end
+      end
+    end
+
+    if matched_component.nil?
+      component_instance.children.each do |child|
+        if child.children.any?
+          matched_component = dig_for_component(component_key, child)
+          break if !matched_component.nil?
+        end
+      end
+      return matched_component
+    else
+      return matched_component
+    end
+
+  end
+
+  # TODO: too many arguments maybe get some of them together?
+  def render_isolated_component(component_class_name, page_instance, controller_instance, context, public_options = nil)
+    component_class = resolve_isolated_component(component_class_name)
+
+    if component_class
+      component_instance = component_class.new(public_options: public_options, context: context)
+      if component_instance.authorized?
+        render_matestack_object(controller_instance, component_instance, {}, :render_isolated_content)
+      else
+        # some 4xx? 404?
+        raise "not authorized"
+      end
+    else
+      # some 404 probably
+      raise "component not found"
+    end
+  end
+
+  def resolve_component(name)
+    constant = const_get(name)
+    # change to specific AsyncComponent parent class
+    if constant < Matestack::Ui::Core::Async::Async
+      constant
+    else
+      nil
+    end
+  rescue NameError
+    nil
+  end
+
+  def resolve_isolated_component(name)
+    constant = const_get(name)
+    if constant < Matestack::Ui::Core::Isolated::Isolated
+      constant
+    else
+      nil
+    end
+  rescue NameError
+    nil
+  end
+
+
+  def resolve_app_class(controller_instance, options)
+    app_class = DEFAULT_APP_CLASS
+
+    controller_level_app_class = controller_instance.class.get_matestack_app_class
+    action_level_app_class = options[:matestack_app]
+
+    if !controller_level_app_class.nil?
+      if controller_level_app_class == false
+        app_class = false
+      else
+        if controller_level_app_class.is_a?(Class) && (controller_level_app_class < Matestack::Ui::App)
+          app_class = controller_level_app_class
+        else
+          raise "#{controller_level_app_class} is not a valid Matestack::Ui::App class"
+        end
+      end
+    end
+    if !action_level_app_class.nil?
+      if action_level_app_class == false
+        app_class = false
+      else
+        matestack_app_class = action_level_app_class
+        if action_level_app_class.is_a?(Class) && (action_level_app_class < Matestack::Ui::App)
+          app_class = action_level_app_class
+        else
+          raise "#{action_level_app_class} is not a valid Matestack::Ui::App class"
+        end
+      end
+    end
+
+    return app_class
+  end
+
+end