matestack-ui-core 1.3.1 → 2.1.0

data/Rakefile

@@ -19,8 +19,6 @@ load 'rails/tasks/engine.rake'
 
 load 'rails/tasks/statistics.rake'
 
-load 'lib/tasks/matestack/ui/core_tasks.rake'
-
 require 'bundler/gem_tasks'
 
 require 'rake/testtask'

data/lib/matestack/ui/app.rb

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

data/lib/matestack/ui/component.rb

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

data/lib/matestack/ui/core.rb

@@ -1,18 +1,68 @@
-require 'trailblazer/cell'
-require 'cell/rails'
-require 'cell/haml'
+base_path = 'matestack/ui/core'
+require "#{base_path}/version"
 
-require "matestack/ui/core/cell"
-require "matestack/ui/core/engine"
+module Matestack
+  module Ui
+    module Core
+
+    end
+  end
+end
+
+require "#{base_path}/context"
+require "#{base_path}/properties"
+require "#{base_path}/base"
+require "#{base_path}/vue_attributes"
+require "#{base_path}/component"
+require "#{base_path}/page"
+require "#{base_path}/app"
+require "#{base_path}/helper"
 
-require "matestack/ui/core/dsl"
-require "matestack/ui/core/component/registry"
-require "matestack/ui/core/components"
+# require abbreveations for apps, pages and components
+require "matestack/ui/app"
+require "matestack/ui/page"
+require "matestack/ui/component"
 
+# VueJs Components
+vue_js_base_path = 'matestack/ui/vue_js'
 module Matestack
   module Ui
-    module Core
-      # Your code goes here...
+    module VueJs
+
     end
   end
 end
+
+require "#{vue_js_base_path}/vue"
+require "#{vue_js_base_path}/components/toggle"
+require "#{vue_js_base_path}/components/onclick"
+require "#{vue_js_base_path}/components/transition"
+require "#{vue_js_base_path}/components/async"
+require "#{vue_js_base_path}/components/action"
+require "#{vue_js_base_path}/components/cable"
+require "#{vue_js_base_path}/components/isolated"
+require "#{vue_js_base_path}/components/form/context"
+require "#{vue_js_base_path}/components/form/base"
+require "#{vue_js_base_path}/components/form/form"
+require "#{vue_js_base_path}/components/form/input"
+require "#{vue_js_base_path}/components/form/textarea"
+require "#{vue_js_base_path}/components/form/checkbox"
+require "#{vue_js_base_path}/components/form/radio"
+require "#{vue_js_base_path}/components/form/select"
+require "#{vue_js_base_path}/components/form/fields_for_remove_item"
+require "#{vue_js_base_path}/components/form/fields_for_add_item"
+require "#{vue_js_base_path}/components/collection/helper"
+require "#{vue_js_base_path}/components/collection/content"
+require "#{vue_js_base_path}/components/collection/filter"
+require "#{vue_js_base_path}/components/collection/filter_reset"
+require "#{vue_js_base_path}/components/collection/next"
+require "#{vue_js_base_path}/components/collection/order"
+require "#{vue_js_base_path}/components/collection/order_toggle"
+require "#{vue_js_base_path}/components/collection/order_toggle_indicator"
+require "#{vue_js_base_path}/components/collection/page"
+require "#{vue_js_base_path}/components/collection/previous"
+require "#{vue_js_base_path}/components"
+require "#{vue_js_base_path}/initialize"
+
+# require abbreveations for apps, pages and components
+require "matestack/ui/vue_js_component"

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

@@ -0,0 +1,36 @@
+module Matestack
+  module Ui
+    module Core
+      class App < Base
+        
+        def initialize(options = {})
+          @controller = Context.controller
+          Context.app = self
+          super(nil, nil, options)
+        end
+
+        def component_attributes
+          {
+            is: 'matestack-ui-core-app',
+            'inline-template': true,
+          }
+        end
+
+        def loading_state_element
+        end
+
+
+        # layout class method to specify if a rails layout should be used
+        def self.inherited(subclass)
+          subclass.layout(@layout)
+          super
+        end
+          
+        def self.layout(layout = nil)
+          @layout = layout ? layout : @layout
+        end
+        
+      end
+    end
+  end
+end

data/lib/matestack/ui/core/base.rb

@@ -0,0 +1,117 @@
+require_relative 'tag_helper'
+
+module Matestack
+  module Ui
+    module Core
+      class Base
+        include ActionView::Helpers::TagHelper
+
+        include Matestack::Ui::Core::Properties
+        include Matestack::Ui::Core::TagHelper
+
+        attr_accessor :html_tag, :text, :options, :parent, :escape, :bind_to_parent
+
+        def initialize(html_tag = nil, text = nil, options = {}, &block)
+          return unless render?
+
+          self.bind_to_parent = ([:without_parent].include?(html_tag) ? false : true)
+          self.slots = self.options.delete(:slots) if self.options
+          # extract_options(text, options) is called in properties
+          self.html_tag = html_tag if self.bind_to_parent
+          self.escape = self.options.delete(:escape) || true
+          self.parent = Matestack::Ui::Core::Context.parent
+          self.parent.children << self if self.parent if self.bind_to_parent
+          self.prepare
+          Matestack::Ui::Core::Context.parent = self
+          create_children(&block)
+          Matestack::Ui::Core::Context.parent = self.parent
+          self
+        end
+
+        # can be optionally overwritten in subclass 
+        # in order to conditionally render the component
+        def render?
+          true
+        end
+
+        # check if text is given and set text and options accordingly
+        def extract_options(text, options)
+          if text.is_a? Hash
+            # we need to dup the text object because we're deleting keys from this object which manipulates the object passed in here
+            # if this object is reused after beeing injected into this component, the keys would be missing
+            self.options = text.dup
+          else
+            self.text = text
+            # we need to dup the options object because we're deleting keys from this object which manipulates the object passed in here
+            # if this object is reused after beeing injected into this component, the keys would be missing
+            self.options = options.dup || {}
+          end
+          self.options.symbolize_keys!
+        end
+
+        def prepare
+          # can be optionally overwritten in subclass in order to set
+          # instance vars for example, might get deprecated in the future
+        end
+
+        # create child items by either running the response method if exists or executing the block
+        # overwrite if needed (like in pages or apps)
+        def create_children(&block)
+          if respond_to?(:response)
+            self.response &block
+          else
+            block.call if block_given?
+          end
+        end
+
+        def self.call(text = nil, options = {}, &block)
+          self.new(nil, text, options, &block).render_content
+        end
+
+        def children
+          @children ||= []
+        end
+
+        def render_content
+          if children.empty?
+            child_content = self.escape ? ERB::Util.html_escape(text) : text if text
+          else
+            # using "\n" in order to preserve the 1.x rendering behavior which impacts appearance in browser
+            child_content = (children.map { |child| " \n " + child.render_content }.join + " \n ").html_safe
+          end
+          result = ''
+          if self.html_tag
+            result = tag.public_send(self.html_tag, child_content, **self.options || {})
+          elsif child_content
+            result = child_content
+          end
+          result
+        end
+
+        def params
+          Matestack::Ui::Core::Context.params || ActionController::Parameters.new({})
+        end
+
+        def view_context
+          if Matestack::Ui::Core::Context.controller.nil?
+            Matestack::Ui::Core::Context.controller = ActionController::Base.new
+          else
+            Matestack::Ui::Core::Context.controller&.view_context
+          end
+        end
+
+        def method_missing(name, *args, &block)
+          return view_context.send(name, *args, &block) if view_context && view_context.respond_to?(name, true)
+          return Rails.application.routes.url_helpers.send(name, *args, &block) if Rails.application.routes.url_helpers.respond_to?(name, true)
+          return raise NameError, "#{name} is not defined for #{self.class}", caller
+        end
+
+        # give easy access to vue data attributes
+        def vue
+          Matestack::Ui::Core::VueAttributes
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module Matestack
+  module Ui
+    module Core
+      class Component < Base
+      end
+    end
+  end
+end

data/lib/matestack/ui/core/context.rb

@@ -0,0 +1,17 @@
+module Matestack
+  module Ui
+    module Core
+      class Context < ActiveSupport::CurrentAttributes
+
+        attribute :app
+        attribute :parent
+        attribute :isolated_parent
+        attribute :params
+        attribute :controller
+        attribute :component_block
+        attribute :async_components
+
+      end
+    end
+  end
+end

data/lib/matestack/ui/core/helper.rb

@@ -0,0 +1,91 @@
+module Matestack
+  module Ui
+    module Core
+      module Helper
+        
+        def self.included(base)
+          base.extend ClassMethods
+        end
+        
+        module ClassMethods
+          def inherited(subclass)
+            subclass.matestack_app(@matestack_app)
+            super
+          end
+          
+          def matestack_app(app = nil)
+            @matestack_app = app ? app : @matestack_app
+          end
+        end
+        
+        def render(*args)
+          setup_context
+          if args.first.is_a?(Class) && args.first.ancestors.include?(Base)
+            raise 'expected a hash as second argument' unless args.second.is_a?(Hash) || args.second.nil?
+
+            begin
+              controller_layout = self.class.send(:_layout)
+            rescue
+              controller_layout = nil
+            end
+
+            options = args.second || {}
+            app = options.delete(:matestack_app) || self.class.matestack_app
+            page = args.first
+
+            if controller_layout == false
+              layout = app ? app.layout : false
+            else
+              if controller_layout.nil?
+                layout = "application"
+              else
+                layout = controller_layout
+              end
+            end
+            
+            if app && params[:only_page].nil? && params[:component_key].nil? && params[:component_class].nil?
+              render_app app, page, options, layout
+            else
+              if params[:component_key] && params[:component_class].nil?
+                render_component app, page, params[:component_key], options
+              elsif params[:component_class]
+                if params[:component_key]
+                  render_component nil, params[:component_class].constantize, params[:component_key], JSON.parse(params[:public_options] || '{}')
+                else 
+                  render html: params[:component_class].constantize.(public_options: JSON.parse(params[:public_options] || '{}'))
+                end
+              else
+                if params[:only_page]
+                  render_page page, options, false
+                else
+                  render_page page, options, layout
+                end
+              end
+            end
+          else
+            super
+          end
+        end
+        
+        def render_app(app, page, options, layout)
+          render html: app.new(options) { page.new(options) }.render_content.html_safe, layout: layout
+        end
+        
+        def render_page(page, options, layout)
+          render html: page.new(options).render_content.html_safe, layout: layout
+        end
+        
+        def render_component(app, page, component_key, options)
+          app ? app.new(options) { page.new(options) } : page.new(options) # create page structure in order to later access registered async components
+          render html: Matestack::Ui::Core::Context.async_components[component_key].render_content.html_safe, layout: false
+        end
+        
+        def setup_context
+          Matestack::Ui::Core::Context.params = self.params
+          Matestack::Ui::Core::Context.controller = (self.class <= ActionController::Base) ? self : @_controller
+        end
+        
+      end
+    end
+  end
+end

data/lib/matestack/ui/core/page.rb

@@ -0,0 +1,57 @@
+module Matestack
+  module Ui
+    module Core
+      class Page < Base
+
+        def initialize(options = {})
+          super(nil, nil, options)
+        end
+
+        def create_children
+          self.page do
+            self.response
+          end
+        end
+
+        def page
+          if params[:only_page]
+            div class: 'matestack-page-root' do
+              yield
+            end
+          else
+            Base.new(:component, component_attributes) do
+              div class: 'matestack-page-container', 'v-bind:class': '{ "loading": loading === true }'  do
+                if Matestack::Ui::Core::Context.app.respond_to? :loading_state_element
+                  div class: 'loading-state-element-wrapper', 'v-bind:class': '{ "loading": loading === true }'  do
+                    Matestack::Ui::Core::Context.app.loading_state_element
+                  end
+                end
+                div class: 'matestack-page-wrapper', 'v-bind:class': '{ "loading": loading === true }' do
+                  div 'v-if': 'asyncPageTemplate == null' do
+                    div class: 'matestack-page-root' do
+                      yield
+                    end
+                  end
+                  div 'v-if': 'asyncPageTemplate != null' do
+                    div class: 'matestack-page-root' do
+                      Base.new('v-runtime-template', ':template': 'asyncPageTemplate')
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        def component_attributes
+          {
+            is: 'matestack-ui-core-page-content',
+            ':params': params.to_json,
+            'inline-template': true
+          }
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+module Matestack
+  module Ui
+    module Core
+      module Properties
+
+        def self.included(base)
+          base.extend ClassMethods
+          base.send :prepend, Initializer
+        end
+
+        module Initializer
+          def initialize(html_tag = nil, text = nil, options = {}, &block)
+            extract_options(text, options)
+            create_context
+            set_text
+            super
+          end
+        end
+
+        module ClassMethods
+          extend Gem::Deprecate
+
+          def required(*args)
+            @required = (@required || []).concat(args)
+          end
+          alias requires required
+
+          def optional(*args)
+            @optional = (@optional || []).concat(args)
+          end
+
+          def required_property_keys
+            @required
+          end
+
+          def optional_property_keys
+            @optional
+          end
+
+          def inherited(subclass)
+            subclass.required(*required_property_keys)
+            subclass.optional(*optional_property_keys)
+            super
+          end
+        end
+
+        def context
+          @context ||= OpenStruct.new
+        end
+        alias :ctx :context
+
+        def required_property_keys
+          self.class.required_property_keys || []
+        end
+
+        def optional_property_keys
+          self.class.optional_property_keys || []
+        end
+
+        def create_context
+          create_context_for_properties(self.required_property_keys, required: true)
+          create_context_for_properties(self.optional_property_keys)
+        end
+
+        def create_context_for_properties(properties, required: false)
+          properties.uniq.each do |property|
+            if property.is_a? Hash
+              property.each do |key, value|
+                method_name = value[:as] || key
+                raise "required property '#{key}' is missing for '#{self.class}'" if required && self.options[key].nil?
+                context.send(:"#{method_name}=", self.options.delete(key))
+              end
+            else
+              raise "required property '#{property}' is missing for '#{self.class}'" if required && self.options[property].nil?
+              context.send(:"#{property}=", self.options.delete(property))
+            end
+          end if properties
+        end
+
+        def set_text
+          # the text property is treated specially since 2.0.0 enables text injection for all components like:
+          #
+          # some_component "foo", class: "whatever" -> self.text -> "foo"
+          #
+          # prior to 2.0.0, text injection happened like that:
+          #
+          # some_component text: "foo", class: "whatever" -> self.options[:text] -> "foo"
+          #
+          # in both cases "foo" should be available via self.context.text AND self.text
+          #
+          # in 2.0.0 text is available via context.text if text is marked as required or optional
+          # in order to have a consistent access, we make this text accessable via self.text as well in this case
+          # in all cases, text is accessable via self.text AND self.context.text
+          # we make the passed in text option available via context.text by default, even if not marked as required or optional
+          #
+          # additionally we need to delete text from the options, as they might be used to be rendered as
+          # tag attributes without any whitelisting as happened prior to 2.0.0
+          self.text = self.options.delete(:text) if self.options.has_key?(:text)
+          self.context.text = self.text
+        end
+        
+      end
+    end
+  end
+end