matestack-ui-core 0.6.0

data/app/concepts/link/cell/link.rb

@@ -0,0 +1,24 @@
+module Link::Cell
+  class Link < Component::Cell::Static
+
+    REQUIRED_KEYS = [:path]
+
+    def setup
+      @tag_attributes.merge!({ "class": options[:class],
+        "id": component_id,
+        "method": options[:method],
+        "target": options[:target] ||= nil
+      })
+    end
+
+    def link_path
+      if options[:path].is_a?(Symbol)
+        return ::Rails.application.routes.url_helpers.send(options[:path], options[:params])
+      end
+      if options[:path].is_a?(String)
+        return options[:path]
+      end
+    end
+
+  end
+end

data/app/concepts/link/view/link.haml

@@ -0,0 +1,6 @@
+- if options[:text].nil?
+  = link_to link_path, @tag_attributes do
+    - if block_given?
+      = yield
+- else
+  = link_to options[:text], link_path, @tag_attributes

data/app/concepts/main/cell/main.rb

@@ -0,0 +1,5 @@
+module Main::Cell
+  class Main < Component::Cell::Static
+
+  end
+end

data/app/concepts/main/view/main.haml

@@ -0,0 +1,3 @@
+%main{@tag_attributes}
+  - if block_given?
+    = yield

data/app/concepts/nav/cell/nav.rb

@@ -0,0 +1,5 @@
+module Nav::Cell
+  class Nav < Component::Cell::Static
+
+  end
+end

data/app/concepts/nav/view/nav.haml

@@ -0,0 +1,3 @@
+%nav{@tag_attributes}
+  - if block_given?
+    = yield

data/app/concepts/ol/cell/ol.rb

@@ -0,0 +1,5 @@
+module Ol::Cell
+  class Ol < Component::Cell::Static
+
+  end
+end

data/app/concepts/ol/view/ol.haml

@@ -0,0 +1,3 @@
+%ol{"class": options[:class], "id": component_id}
+  - if block_given?
+    = yield

data/app/concepts/onclick/cell/onclick.rb

@@ -0,0 +1,6 @@
+module Onclick::Cell
+    class Onclick < Component::Cell::Dynamic
+
+
+    end
+  end

data/app/concepts/onclick/js/onclick.js

@@ -0,0 +1,21 @@
+import Vue from 'vue/dist/vue.esm'
+
+import matestackEventHub from 'core/js/event-hub'
+
+import componentMixin from 'component/js/component'
+
+const componentDef = {
+  mixins: [componentMixin],
+  data: function(){
+    return { }
+  },
+  methods: {
+    perform: function(){
+      matestackEventHub.$emit(this.componentConfig["emit"], this.componentConfig["data"])
+    }
+  }
+}
+
+let component = Vue.component('onclick-cell', componentDef)
+
+export default componentDef

data/app/concepts/onclick/view/onclick.haml

@@ -0,0 +1,2 @@
+%div{"@click": "perform"}
+  = yield

data/app/concepts/page/cell/content.rb

@@ -0,0 +1,5 @@
+module Page::Cell
+  class Content < Component::Cell::Dynamic
+
+  end
+end

data/app/concepts/page/cell/page.rb

@@ -0,0 +1,128 @@
+module Page::Cell
+  class Page < Trailblazer::Cell
+
+    include ActionView::Helpers::TranslationHelper
+    include ::Cell::Haml
+    include ::Matestack::Ui::Core::ApplicationHelper
+    include ::Shared::Utils::ToCell
+
+    view_paths << "#{Matestack::Ui::Core::Engine.root}/app/concepts"
+
+    def initialize(model=nil, options={})
+      super
+      generate_page_name
+      set_app_class
+      @nodes = {}
+      @cells = {}
+      options[:controller_instance].instance_variables.each do |controller_instance_var_key|
+        unless controller_instance_var_key.to_s.start_with?("@_")
+          self.instance_variable_set(controller_instance_var_key, options[:controller_instance].instance_variable_get(controller_instance_var_key))
+        end
+      end
+    end
+
+    def prepare
+      true
+    end
+
+    def components(&block)
+      @nodes = ::Page::Utils::PageNode.build(self, nil, &block)
+    end
+
+    def nodes_to_cell
+      @nodes.each do |key, node|
+        @cells[key] = to_cell(key, node["component_name"], node["config"], node["argument"], node["components"], node["included_config"])
+      end
+    end
+
+    def partial(&block)
+      return block
+      # ::Page::Utils::PageNode.build(self, included, &block)
+    end
+
+    def slot(&block)
+      # return block
+      ::Page::Utils::PageNode.build(self, nil, &block)
+    end
+
+
+    def show(component_key=nil, only_page=false)
+      prepare
+      response
+
+      render_mode = nil
+      render_mode = :only_page if only_page == true
+      render_mode = :render_page_with_app if !@app_class.nil? && only_page == false
+      render_mode = :only_page if @app_class.nil? && only_page == false
+      render_mode = :render_component if !component_key.nil?
+
+      case render_mode
+
+      when :only_page
+        nodes_to_cell
+        # keys_array = ["div_2","components", "partial_1", "components", "form_1"]
+        # puts @nodes.dig(*keys_array)
+        render :page
+      when :render_page_with_app
+        concept(@app_class).call(:show, @page_id, @nodes)
+      when :render_component
+        if component_key.include?("__")
+          keys_array = component_key.gsub("__", "__components__").split("__").map {|k| k.to_s}
+          page_content_keys = keys_array.select{|key| key.match(/^page_content_/)}
+          if page_content_keys.any?
+            keys_array = keys_array.drop(keys_array.find_index(page_content_keys[0])+2)
+          end
+          node = @nodes.dig(*keys_array)
+          cell = to_cell(component_key, node["component_name"], node["config"], node["argument"], node["components"], node["included_config"])
+          return cell.render_content
+        else
+          node = @nodes[component_key]
+          cell = to_cell(component_key, node["component_name"], node["config"], node["argument"], node["components"], node["included_config"])
+          return cell.render_content
+        end
+      end
+    end
+
+
+    def page_id
+      @custom_page_id ||= @page_id
+    end
+
+    private
+
+      def generate_page_name
+        name_parts = self.class.name.split("::").map { |name| name.underscore }
+        @page_id = name_parts.join("_")
+      end
+
+      def set_app_class
+        class_name = self.class.name
+        name_parts = class_name.split("::")
+        if name_parts.count <= 2
+          @app_class = nil
+          return
+        end
+
+        app_name = "#{name_parts[1]}"
+        begin
+          app_class = Apps.const_get(app_name)
+          if app_class.is_a?(Class)
+            @app_class = app_class
+          else
+            require_dependency "apps/#{app_name.underscore}"
+            app_class = Apps.const_get(app_name)
+            if app_class.is_a?(Class)
+              @app_class = app_class
+            else
+              @app_class = nil
+            end
+          end
+        rescue
+          @app_class = nil
+        end
+      end
+
+
+  end
+
+end

data/app/concepts/page/js/content.js

@@ -0,0 +1,17 @@
+import Vue from 'vue/dist/vue.esm'
+import Vuex from 'vuex'
+import componentMixin from 'component/js/component'
+
+const componentDef = {
+  mixins: [componentMixin],
+  data: function(){
+    return {}
+  },
+  computed: Vuex.mapState({
+    asyncPageTemplate: state => state.pageTemplate,
+  })
+}
+
+let component = Vue.component('page-content-cell', componentDef)
+
+export default componentDef

data/app/concepts/page/utils/page_node.rb

@@ -0,0 +1,66 @@
+module Page::Utils
+  class PageNode
+
+    def self.build(page_instance, included_config, &block)
+      node = PageNode.new(page_instance, included_config)
+      node.instance_eval(&block)
+      node.hash
+    end
+
+    attr_reader :hash
+
+    def initialize(page_instance, included_config)
+      @hash = {}
+      @node_start_id = 0
+      @included_config = included_config
+      @page_instance = page_instance
+      page_instance.instance_variables.each do |page_instance_var_key|
+        self.instance_variable_set(page_instance_var_key, page_instance.instance_variable_get(page_instance_var_key))
+      end
+    end
+
+    def method_missing meth, *args, &block
+      begin
+        @page_instance.send(meth, *args, &block)
+      rescue
+        node_id = @node_start_id + 1
+        @node_start_id = node_id
+        current_node = "#{meth}_#{@node_start_id}"
+        @hash[current_node] = {}
+        @hash[current_node]["component_name"] = meth.to_s
+        @hash[current_node]["config"] = {}
+        @hash[current_node]["included_config"] = @included_config
+        @hash[current_node]["argument"] = nil
+
+        if args.second == :include
+          included = args.first
+        else
+          unless @included_config.nil?
+            included = @included_config
+          else
+            included = nil
+          end
+        end
+
+        if meth == :partial
+          partial_block = @page_instance.send(args.first, *args.drop(1))
+          @hash[current_node]["components"] = PageNode.build(
+            @page_instance, included, &partial_block
+          )
+        else
+          if args.first.is_a?(Hash)
+            @hash[current_node]["config"] = args.first
+          else
+            @hash[current_node]["argument"] = args.first
+          end
+
+          if block_given?
+            @hash[current_node]["components"] = PageNode.build(@page_instance, included, &block)
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/app/concepts/page/view/content.haml

@@ -0,0 +1,7 @@
+%div{"class": "matestack_page"}
+  %div{"v-if": "asyncPageTemplate == null"}
+    %div{"class": "matestack_page_content"}
+      - @children_cells.each do |key, cell|
+        = cell.call(:show)
+  %div{"v-if": "asyncPageTemplate != null"}
+    %v-runtime-template{":template":"asyncPageTemplate"}

data/app/concepts/page/view/page.haml

@@ -0,0 +1,9 @@
+- if context[:params][:only_page] == "true"
+  %div{class: "matestack_page_content"}
+    - @cells.each do |key, cell|
+      = cell.call(:show)
+- else
+  %div{class: "matestack_page"}
+    %div{class: "matestack_page_content"}
+      - @cells.each do |key, cell|
+        = cell.call(:show)

data/app/concepts/partial/cell/partial.rb

@@ -0,0 +1,5 @@
+module Partial::Cell
+  class Partial < Component::Cell::Static
+
+  end
+end

data/app/concepts/partial/view/partial.haml

@@ -0,0 +1,2 @@
+- @children_cells.each do |key, cell|
+  = cell.call(:show)

data/app/concepts/pg/cell/pg.rb

@@ -0,0 +1,5 @@
+module Pg::Cell
+  class Pg < Component::Cell::Static
+
+  end
+end

data/app/concepts/pg/view/pg.haml

@@ -0,0 +1,8 @@
+- if options[:text].nil?
+  %p{@tag_attributes}
+    - if block_given?
+      = yield
+
+- else
+  %p{@tag_attributes}
+    = options[:text]

data/app/concepts/plain/cell/plain.rb

@@ -0,0 +1,10 @@
+module Plain::Cell
+  class Plain < Component::Cell::Static
+
+    def show
+      @argument
+    end
+
+  end
+
+end

data/app/concepts/progress/cell/progress.rb

@@ -0,0 +1,5 @@
+module Progress::Cell
+  class Progress < Component::Cell::Static
+
+  end
+end

data/app/concepts/progress/view/progress.haml

@@ -0,0 +1,3 @@
+%progress{"id": component_id, "class": options[:class], "value": options[:value], "max": options[:max]}
+  - if block_given?
+    = yield

data/app/concepts/section/cell/section.rb

@@ -0,0 +1,5 @@
+module Section::Cell
+  class Section < Component::Cell::Static
+
+  end
+end

data/app/concepts/section/view/section.haml

@@ -0,0 +1,3 @@
+%section{@tag_attributes}
+  - if block_given?
+    = yield

data/app/concepts/shared/utils/to_cell.rb

@@ -0,0 +1,126 @@
+module Shared::Utils::ToCell
+
+  def to_cell(key, component_name, config, argument, children, included_config)
+    request_uri = context[:request].env["REQUEST_URI"]
+    query_string = context[:request].env["QUERY_STRING"]
+
+    config.merge!(component_key: key)
+    config.merge!(children: children)
+    config.merge!(origin_url: request_uri.gsub("?" + query_string, ""))
+    config.merge!(url_params: context[:params])
+    config.merge!(included_config: included_config)
+
+    if component_name.start_with?("custom")
+      return resolve_custom_component(component_name, argument, config)
+    else
+      return resolve_core_component(component_name, argument, config)
+    end
+
+  end
+
+  private
+
+  def resolve_custom_component(component_name, argument, config)
+    name = component_name.gsub("_", "/")
+
+    path = name.split("/")[1..-1]
+    path_camelized = path.map { |x| x.camelize }
+
+    if path_camelized.count == 1
+      class_name = "#{path_camelized[0]}::Cell::#{path_camelized[0]}"
+      rewritten_path = [path[0], "cell", path[0]]
+    else
+      class_name = path_camelized[0..-2].join("::")
+      class_name += "::Cell::#{path_camelized[-1]}"
+      rewritten_path = path[0..-2]
+      rewritten_path << "cell"
+      rewritten_path << path[-1]
+    end
+
+    custom_component_class_name = "Components::" + class_name
+
+    begin
+      begin
+        component_class = Object.const_get(custom_component_class_name, false)
+      rescue => e
+        raise "#{e.message.nil? ? '': 'Got Error: '+e.message}. \
+              Make sure to define your custom component class correctly \
+              in \"matestack/components/#{rewritten_path.join('/')}.rb\""
+      end
+      if component_class.is_a?(Class)
+        return concept(component_class, argument, config)
+      else
+        raise "Given component #{component_class} is not a class. \
+        You might forget to add the component name to your component call"
+      end
+    rescue => e
+      raise "#{component_name} > #{e.message}"
+    end
+
+  end
+
+  def resolve_core_component(component_name, argument, config)
+    name = component_name.gsub("_", "/")
+
+    if name.include?("/")
+      name = name.gsub("/", "/cell/")
+    else
+      name = "#{name}/cell/#{name}"
+    end
+
+    path = name.split("/")
+    path_camelized = path.map { |x| x.camelize }
+    class_name = path_camelized.join("::")
+
+    begin
+      begin
+        component_class = Object.const_get(class_name, false)
+      rescue => e
+        begin
+          return resolve_namespaced_component(component_name, argument, config)
+        rescue => e
+          raise "#{e.message.nil? ? '': 'Got Error: '+e.message}. \
+          Component '#{component_name}' not found. Looking for Class '#{class_name}'. \
+          Make sure to prefix a custom component with 'custom_'"
+        end
+      end
+      return concept(component_class, argument, config)
+    rescue => e
+      raise "#{component_name} > #{e.message}"
+    end
+
+  end
+
+  def resolve_namespaced_component(component_name, argument, config)
+    name = component_name.gsub("_", "/")
+
+    path = name.split("/")[1..-1]
+    namespace = name.split("/")[0].camelize
+    path_camelized = path.map { |x| x.camelize }
+
+    if path_camelized.count == 1
+      class_name = "#{path_camelized[0]}::Cell::#{path_camelized[0]}"
+      rewritten_path = [path[0], "cell", path[0]]
+    else
+      class_name = path_camelized[0..-2].join("::")
+      class_name += "::Cell::#{path_camelized[-1]}"
+      rewritten_path = path[0..-2]
+      rewritten_path << "cell"
+      rewritten_path << path[-1]
+    end
+
+    namespaced_class_name = namespace + "::" + class_name
+
+    begin
+      begin
+        component_class = Object.const_get(namespaced_class_name, false)
+      rescue => e
+        raise "#{e.message}"
+      end
+      return concept(component_class, argument, config)
+    rescue => e
+      raise "#{e.message}"
+    end
+  end
+
+end