matestack-ui-core 1.3.0 → 2.0.0

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

@@ -1,111 +0,0 @@
-module Matestack
-  module Ui
-    module Core
-      # We're called ApplicationHelper but all we do so far is rendering.
-      module ApplicationHelper
-
-        # 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
-
-        end
-
-        # 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
-        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
-            super
-          end
-        end
-
-        # Kept around for compatibility. Probably worth removing.
-        def responder_for(*args)
-          render(*args)
-        end
-
-        def matestack_component(component, options = {}, &block)
-          controller = (self.class <= ActionController::Base) ? self : @_controller
-          context = (options[:matestack_context] ||= {}).merge(controller: controller)
-          Matestack::Ui::Core::Component::Base
-            .new(options.merge(context: context, matestack_context: context))
-            .send(component, options.merge(context: context, matestack_context: context), &block).to_s
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-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 formInputMixin from '../../../app/concepts/matestack/ui/core/form/input/mixin'
-import formSelectMixin from '../../../app/concepts/matestack/ui/core/form/select/mixin'
-import formRadioMixin from '../../../app/concepts/matestack/ui/core/form/radio/mixin'
-import formCheckboxMixin from '../../../app/concepts/matestack/ui/core/form/checkbox/mixin'
-import formTextareaMixin from '../../../app/concepts/matestack/ui/core/form/textarea/mixin'
-import matestackUiCore from '../../../app/concepts/matestack/ui/core/js/core'
-
-import styles from './styles/index.scss'
-
-const MatestackUiCore = {
-  Vue,
-  Vuex,
-  axios,
-  matestackEventHub,
-  componentMixin,
-  formInputMixin,
-  formSelectMixin,
-  formCheckboxMixin,
-  formTextareaMixin,
-  formRadioMixin
-}
-
-window.MatestackUiCore = MatestackUiCore
-
-export default MatestackUiCore

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

@@ -1,5 +0,0 @@
-// 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

@@ -1,8 +0,0 @@
-// // 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/app.rb

@@ -1 +0,0 @@
-Matestack::Ui::App = Matestack::Ui::Core::App::App

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

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

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

@@ -1,16 +0,0 @@
-module Matestack::Ui::Core::HasViewContext
-  def initialize(*args)
-    super
-    @view_context = @options.dig(:context, :view_context)
-    unless @view_context
-      @view_context = @options.dig(:matestack_context, :controller)&.view_context
-    end
-  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

@@ -1,43 +0,0 @@
-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
-  ]
-
-  def self.included(base)
-    base.class_eval do
-      extend ClassMethods
-    end
-  end
-
-  module ClassMethods
-
-    def inherited(subclass)
-      super
-      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

@@ -1,161 +0,0 @@
-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)
-      set_values(options) unless options[:skip_set_values]
-      super
-    end
-  end
-  
-  module ClassMethods
-
-    def inherited(subclass)
-      super
-      # self.new(nil, skip_set_values: true)
-      subclass.property_keys *self.all_property_keys
-      subclass.all_required_properties.concat(self.all_required_properties)
-      subclass.created_properties.concat(self.created_properties)
-    end
-    
-    # contains all property keys, or property hashes regardless of wheter they are optional or required
-    # used in order to initialize values of properties correctly for subclasses and make properties inheritable
-    def all_property_keys
-      @all_properties.flatten!&.uniq! if defined? @all_properties
-      @all_properties ||= []
-    end
-
-    def all_required_properties
-      @all_required_properties ||= []
-    end
-
-    def created_properties
-      @created_properties ||= []
-    end
-
-    # add property keys to array containing all property keys
-    def property_keys(*attributes)
-      attributes.each do |attribute|
-        if attribute.is_a?(Hash)
-          attribute.each do |temp|
-            all_property_keys.push({ "#{temp.first}": temp.last})
-          end
-        else
-          all_property_keys.push(attribute) 
-        end
-      end
-    end
-
-    # define optinoal properties for custom components with `optional :foo, :bar`
-    def optional(*properties)
-      property_keys *properties
-      add_properties_to_list(optional_properties, properties)
-      optional_hooks
-    end
-  
-    # define required properties for custom components with `requires :title, :foo, :bar`
-    def requires(*properties)
-      property_keys *properties
-      add_properties_to_list(requires_properties, properties)
-      required_hooks
-    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
-      @optional_properties ||= []
-    end
-  
-    # array of required properties from the component
-    def requires_properties
-      @requires_properties ||= []
-    end
-
-    def optional_hooks
-      self.optional_properties.compact.each do |prop|
-        prop = extract_property_key({}, prop)
-        define_getter_and_setter_for_property(prop)
-      end
-    end
-
-    def required_hooks
-      self.requires_properties.compact.each do |prop|
-        prop = extract_property_key({}, prop)
-        self.all_required_properties.push(prop).uniq!
-        define_getter_and_setter_for_property(prop)
-      end
-    end
-
-    def extract_property_key(options, prop)
-      if prop.is_a?(Array) || prop.is_a?(Hash)
-        hash = prop.flatten
-        prop = hash.last[:as]
-      end
-      prop
-    end
-
-    def define_getter_and_setter_for_property(prop)
-      self.created_properties.push(prop)
-      self.send(:define_method, prop) do 
-        self.instance_variable_get(:"@#{prop}")
-      end
-      self.send(:define_method, :"#{prop}=") do |value|
-        self.instance_variable_set(:"@#{prop}", value)
-      end
-    end
-
-    def method_added(name)
-      if all_property_keys.include?(name) && !created_properties.include?(name)
-        raise PropertyOverwritingExistingMethodException, "Property \"#{name}\" would overwrite already defined instance method for #{self}"
-      end
-    end
-  end
-
-  def set_values(options)
-    self.class.all_property_keys.compact.each do |prop|
-      value_key = prop
-      prop = extract_property_key(options, prop)
-      if self.class.all_required_properties.include?(prop) && options[prop].nil?
-        raise PropertyMissingException, "Required property #{prop} is missing for #{self.class}" 
-      end
-      send(:"#{prop}=", options[prop])
-    end
-  end
-
-  # returns property key and sets alias if hash with as option is given
-  def extract_property_key(options, prop)
-    if prop.is_a?(Array) || prop.is_a?(Hash)
-      hash = prop.flatten
-      options[hash.last[:as]] = options[hash.first]
-      prop = hash.last[:as]
-    end
-    prop
-  end
-
-end

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

@@ -1,33 +0,0 @@
-# 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

@@ -1,203 +0,0 @@
-# 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
-      app_instance = app_class.new(page_class, controller_instance, context)
-      component_key = params[:component_key]
-      page_instance = page_class.new(controller_instance: controller_instance, context: context)
-      render_component(component_key, app_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
-
-  # needs refactoring!
-  # we shouldn't pass in the parts of the controller_instance and the instance itself
-  def create_context_hash(controller_instance)
-    {
-      view_context: controller_instance.view_context,
-      params: controller_instance.params,
-      request: controller_instance.request,
-      controller: controller_instance # if this is not included here, rails route helpers will fail with undefined method `url_options' for nil:NilClass in some cases
-    }
-  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, app_or_page_instance, controller_instance, context)
-    matched_component = nil
-
-    app_or_page_instance.matestack_set_skip_defer(false)
-
-    app_or_page_instance.prepare
-    app_or_page_instance.response
-
-    matched_component = dig_for_component(component_key, app_or_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