matestack-ui-core 0.7.6 → 1.2.0

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

@@ -1,3 +1,3 @@
-%video{@tag_attributes}
-  %source{:src => @source, :type => @type}
+%video{ html_attributes }
+  %source{ src: @source, type: @type}
   Your browser does not support the video tag.

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

@@ -1,22 +1,12 @@
 module Matestack::Ui::Core::Video
   class Video < Matestack::Ui::Core::Component::Static
+    html_attributes :autoplay, :controls, :height, :loop, :muted, :poster, :preload, :src, :width
 
-    REQUIRED_KEYS = [:path, :type]
+    requires :path, :type
 
     def setup
-      @tag_attributes.merge!({
-        autoplay: options[:autoplay],
-        controls: options[:controls],
-        height: options[:height],
-        loop: options[:loop],
-        muted: options[:muted],
-        playsinline: options[:playsinline],
-        preload: options[:preload],
-        width: options[:width]
-      })
-
-      @source = ActionController::Base.helpers.asset_path(options[:path])
-      @type = "video/#{@options[:type]}"
+      @source = ActionController::Base.helpers.asset_path(path)
+      @type = "video/#{type}"
     end
 
   end

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

@@ -0,0 +1 @@
+= include_partial

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

@@ -0,0 +1,30 @@
+require_dependency "cell/partial"
+
+module Matestack::Ui::Core::View
+  class View < Matestack::Ui::Core::Component::Static
+    include Cell::ViewModel::Partial
+    view_paths << "#{::Rails.root}/app/views"
+
+    # Only one option should be set at a time. If view is set partial will be ignored.
+    optional view: { as: :view_path } # Specify a view path to render
+    optional partial: { as: :partial_path } # Specifiy a partial to render
+
+    def include_partial
+      controller = @view_context.present? ? @view_context.controller : options[:matestack_context][:controller]
+      if view_path
+        controller.render_to_string view_path, layout: false, locals: locals
+      elsif partial_path
+        controller.render_to_string partial: partial_path, layout: false, locals: locals
+      else  
+        raise 'view or partial param missing for RailsView Component'
+      end
+    end
+
+    private
+
+    def locals
+      options.except(:matestack_context, :partial, :view, :partial_path, :view_path, :included_config, :context)
+    end
+
+  end
+end

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

@@ -1 +1,5 @@
-%wbr{@tag_attributes}
+%wbr{ html_attributes }
+  - if text.nil? && block_given?
+    = yield
+  - else
+    = text

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

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

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

@@ -1 +1 @@
-%iframe{@tag_attributes}
+%iframe{ youtube_attributes }

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

@@ -1,25 +1,27 @@
 module Matestack::Ui::Core::Youtube
   class Youtube < Matestack::Ui::Core::Component::Static
+    html_attributes :allow, :allowfullscreen, :allowpaymentrequest, :height, :name, 
+      :referrerpolicy, :sandbox, :src, :srcdoc, :width
 
-    REQUIRED_KEYS = [:yt_id, :height, :width]
+    requires :youtube_id
+    optional :privacy_mode, :no_controls, :start_at
 
     def setup
-      url = 'https://www.youtube.com/embed/'
-      url = 'https://www.youtube-nocookie.com/embed/' if options[:privacy_mode] == true
-      url << options[:yt_id]
-      url << '?' unless options[:no_controls] != true and options[:start_at].nil?
-      url << 'controls=0' if options[:no_controls] == true
-      url << '&amp;' if (options[:no_controls] != nil) and (options[:start_at] != nil)
-      url << "start=#{options[:start_at]}" unless options[:start_at].nil?
+      url = privacy_mode ? 'https://www.youtube-nocookie.com/embed/' : 'https://www.youtube.com/embed/'
+      @uri = URI("#{url}#{youtube_id}")
+      @uri.query = { 
+        controls: (no_controls ? 0 : 1),
+        start: start_at
+      }.to_query
+    end
 
-      @tag_attributes.merge!({
-        'src': url,
-        'allow': 'accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture',
-        'allowfullscreen': '',
-        'frameborder': 0,
-        'height': options[:height],
-        'width': options[:width]
-      })
+    def youtube_attributes
+      html_attributes.merge(
+        src: @uri.to_s,
+        allow: 'accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture',
+        allowfullscreen: '',
+        frameborder: 0,
+      )
     end
 
   end

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

@@ -1,37 +1,110 @@
 module Matestack
   module Ui
     module Core
+      # We're called ApplicationHelper but all we do so far is rendering.
       module ApplicationHelper
-        include Matestack::Ui::Core::Render
-
-        def render_page(page_class, only_page=false)
-          page_class.new(nil, context: {
-            params: params,
-            request: request,
-            view_context: view_context
-          }, 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
 
-        def render_component(page_class, component_key)
-          page_class.new(nil, context: {
-            params: params,
-            request: request,
-            view_context: view_context
-          }, controller_instance: self).call(:show, component_key)
+        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
 
-        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)
+          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

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

@@ -1,14 +1,16 @@
 module Matestack::Ui::Core::HasViewContext
-  def initialize(model = nil, options = {})
-    @view_context = options[:context][:view_context]
+  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
-      super
+      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
+  ]
+
+  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

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