jinda 0.7.7.4 → 1.0.0

data/lib/jinda/mindmap_converter.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module MindmapConverter
+  class << self
+    # Convert FreeMind XML to jsMind JSON format
+    def xml_to_jsmind(xml_string)
+      require 'rexml/document'
+      
+      doc = REXML::Document.new(xml_string)
+      root_node = doc.elements['//node[@TEXT="Jinda"]'] || doc.elements['//node'].first
+      
+      unless root_node
+        return default_mindmap
+      end
+
+      {
+        meta: {
+          name: 'Jinda Mindmap',
+          author: 'Jinda Generator',
+          version: '1.0'
+        },
+        format: 'node_tree',
+        data: parse_node(root_node)
+      }
+    end
+
+    # Convert jsMind JSON to FreeMind XML format
+    def jsmind_to_xml(json_hash)
+      require 'rexml/document'
+      
+      doc = REXML::Document.new
+      doc << REXML::XMLDecl.new('1.0', 'UTF-8')
+      
+      map = doc.add_element('map', { 'version' => '1.0.1' })
+      
+      # Build the tree from JSON data
+      data = json_hash.is_a?(String) ? JSON.parse(json_hash) : json_hash
+      build_node(map, data['data'] || data[:data])
+      
+      # Format output
+      formatter = REXML::Formatters::Pretty.new(2)
+      formatter.compact = true
+      output = String.new
+      formatter.write(doc, output)
+      output
+    end
+
+    private
+
+    # Parse XML node recursively to jsMind format
+    def parse_node(xml_node)
+      text = xml_node.attributes['TEXT'].to_s
+      node_id = xml_node.attributes['ID'] || generate_id
+      position = xml_node.attributes['POSITION']
+      
+      # Extract icon if present
+      icon_elem = xml_node.elements['icon']
+      icon = icon_elem&.attributes&.[]('BUILTIN')
+      
+      # Build node data
+      node_data = {
+        id: node_id,
+        topic: text
+      }
+      
+      # Add position for main branches
+      node_data[:direction] = position if position
+      
+      # Extract custom data (icon, role, rule, etc.)
+      custom_data = {}
+      custom_data[:icon] = icon if icon
+      
+      # Collect option nodes (role, rule, confirm, display)
+      option_nodes = []
+      
+      # Parse children
+      children = []
+      xml_node.each_element('node') do |child_node|
+        child_text = child_node.attributes['TEXT']
+        
+        # Check if it's an option node
+        if child_text =~ /^(role|rule|confirm|display):\s*(.+)/i
+          option_type = $1.downcase
+          option_value = $2.strip
+          custom_data[option_type.to_sym] = option_value
+          option_nodes << child_node
+        else
+          # Regular child node
+          children << parse_node(child_node)
+        end
+      end
+      
+      # Add custom data if present
+      node_data[:data] = custom_data unless custom_data.empty?
+      
+      # Add children if present
+      node_data[:children] = children unless children.empty?
+      
+      node_data
+    end
+
+    # Build XML node recursively from jsMind data
+    def build_node(parent_xml, node_data)
+      return unless node_data
+      
+      # Create node attributes
+      attrs = {
+        'TEXT' => node_data['topic'] || node_data[:topic],
+        'ID' => node_data['id'] || node_data[:id] || generate_id
+      }
+      
+      # Add position if present
+      if node_data['direction'] || node_data[:direction]
+        attrs['POSITION'] = node_data['direction'] || node_data[:direction]
+      end
+      
+      # Add CREATED and MODIFIED timestamps
+      timestamp = (Time.now.to_f * 1000).to_i
+      attrs['CREATED'] = timestamp.to_s
+      attrs['MODIFIED'] = timestamp.to_s
+      
+      # Create the node element
+      node_elem = parent_xml.add_element('node', attrs)
+      
+      # Add icon if present in custom data
+      custom_data = node_data['data'] || node_data[:data]
+      if custom_data
+        if custom_data['icon'] || custom_data[:icon]
+          icon_elem = node_elem.add_element('icon')
+          icon_elem.attributes['BUILTIN'] = custom_data['icon'] || custom_data[:icon]
+        end
+        
+        # Add option nodes (role, rule, etc.) as child nodes
+        %w[role rule confirm display].each do |opt|
+          value = custom_data[opt] || custom_data[opt.to_sym]
+          if value
+            option_attrs = {
+              'TEXT' => "#{opt}: #{value}",
+              'ID' => generate_id,
+              'CREATED' => timestamp.to_s,
+              'MODIFIED' => timestamp.to_s
+            }
+            node_elem.add_element('node', option_attrs)
+          end
+        end
+      end
+      
+      # Add children recursively
+      children = node_data['children'] || node_data[:children]
+      if children && children.is_a?(Array)
+        children.each do |child|
+          build_node(node_elem, child)
+        end
+      end
+    end
+
+    def generate_id
+      "ID_#{rand(100000000..999999999)}"
+    end
+
+    def default_mindmap
+      {
+        meta: {
+          name: 'Jinda Mindmap',
+          author: 'Jinda Generator',
+          version: '1.0'
+        },
+        format: 'node_tree',
+        data: {
+          id: 'root',
+          topic: 'Jinda',
+          children: [
+            {
+              id: 'models',
+              topic: 'models',
+              direction: 'left',
+              children: []
+            },
+            {
+              id: 'services',
+              topic: 'services',
+              direction: 'right',
+              children: []
+            },
+            {
+              id: 'roles',
+              topic: 'roles',
+              direction: 'right',
+              children: []
+            }
+          ]
+        }
+      }
+    end
+  end
+end

data/lib/jinda/railtie.rb

@@ -1,12 +1,20 @@
+# frozen_string_literal: true
+
 require 'jinda'
 require 'jinda/helpers'
 
 module Jinda
   require 'rails'
   class Railtie < Rails::Railtie
-    initializer 'testing' do |app|
-      ActionController::Base.send :include, Jinda::Helpers
+    initializer 'testing' do |_app|
+      ActiveSupport.on_load(:action_controller) { include Jinda::Helpers }
+    end
+    
+    initializer 'jinda.omniauth', after: :load_config_initializers do |_app|
+      # Ensure OmniAuth allows both GET and POST for callback routes
+      OmniAuth.config.allowed_request_methods = [:post, :get] if defined?(OmniAuth)
     end
+    
     rake_tasks do
       load 'tasks/jinda.rake'
     end

data/lib/jinda/rake_views.rb

@@ -1,63 +1,64 @@
-    ########################################################################
-    #                            Jinda Rake Task                           #
-    ########################################################################
-
-    def gen_views(prefix="")
-      @prefix = prefix.empty? ? "" : (prefix+"/")
-      t = ["*** generate ui ***"]
-
-      # create array of files to be tested
-      $afile = Array.new
-
-      Jinda::Module.all.each do |m|
-        m.services.each do |s|
-          dir = @prefix + "app/views/#{s.module.code}"
-          unless gen_view_file_exist?(dir)
-            gen_view_mkdir(dir,t) 
-          end
-
-          if s.code=='link'
-            f= @prefix+"app/views/#{s.module.code}/index.haml"
-            $afile << f
-            unless gen_view_file_exist?(f)
-              # check if test (@prefix) 
-              # sv = "app/jinda/template/linkview.haml"
-              sv = @prefix.blank? ? "app/jinda/template/linkview.haml" : "lib/generators/jinda/templates/app/jinda/template/linkview.haml"
-              f= @prefix+"app/views/#{s.module.code}/index.haml"
-              gen_view_createfile(sv,f,t)
-            end
-            next   
-          end
-
-          dir = @prefix+"app/views/#{s.module.code}/#{s.code}"
-          unless gen_view_file_exist?(dir)
-            gen_view_mkdir(dir,t) 
-          end
-
-          xml= REXML::Document.new(s.xml)
-          xml.elements.each('*/node') do |activity|
-            icon = activity.elements['icon']
-            next unless icon
-            action= freemind2action(icon.attributes['BUILTIN'])
-            next unless ui_action?(action)
-            code_name = activity.attributes["TEXT"].to_s
-            next if code_name.comment?
-            code= name2code(code_name)
-            if action=="pdf"
-              f= @prefix + "app/views/#{s.module.code}/#{s.code}/#{code}.pdf.prawn"
-            else
-              f= @prefix + "app/views/#{s.module.code}/#{s.code}/#{code}.html.erb"
-            end
-            $afile << f
-            unless gen_view_file_exist?(f)
-              # sv = "app/jinda/template/view.html.erb"
-              sv = @prefix.blank? ? "app/jinda/template/linkview.haml" : "lib/generators/jinda/templates/app/jinda/template/linkview.haml"
-              gen_view_createfile(sv,f,t)
-            end
-          end
+# frozen_string_literal: true
+
+########################################################################
+#                            Jinda Rake Task                           #
+########################################################################
+
+def gen_views(prefix = "")
+  @prefix = prefix.empty? ? "" : "#{prefix}/"
+  t       = ["*** generate ui ***"]
+
+  # create array of files to be tested
+  $afile = []
+
+  Jinda::Module.all.each do |m|
+    m.services.each do |s|
+      dir = @prefix + "app/views/#{s.module.code}"
+      gen_view_mkdir(dir, t) unless gen_view_file_exist?(dir)
+
+      if s.code == "link"
+        f = @prefix + "app/views/#{s.module.code}/index.haml"
+        $afile << f
+        unless gen_view_file_exist?(f)
+          # check if test (@prefix)
+          # sv = "app/jinda/template/linkview.haml"
+          sv = @prefix.blank? ? "app/jinda/template/linkview.haml" : "lib/generators/jinda/templates/app/jinda/template/linkview.haml"
+          f  = @prefix + "app/views/#{s.module.code}/index.haml"
+          gen_view_createfile(sv, f, t)
         end
+        next
+      end
+
+      dir = @prefix + "app/views/#{s.module.code}/#{s.code}"
+      gen_view_mkdir(dir, t) unless gen_view_file_exist?(dir)
+
+      xml = REXML::Document.new(s.xml)
+      xml.elements.each("*/node") do |activity|
+        icon = activity.elements["icon"]
+        next unless icon
+
+        action = freemind2action(icon.attributes["BUILTIN"])
+        next unless ui_action?(action)
+
+        code_name = activity.attributes["TEXT"].to_s
+        next if code_name.comment?
+
+        code = name2code(code_name)
+        f    = if action == "pdf"
+                 @prefix + "app/views/#{s.module.code}/#{s.code}/#{code}.pdf.prawn"
+               else
+                 @prefix + "app/views/#{s.module.code}/#{s.code}/#{code}.html.erb"
+               end
+        $afile << f
+        next if gen_view_file_exist?(f)
+
+        # sv = "app/jinda/template/view.html.erb"
+        sv = @prefix.blank? ? "app/jinda/template/linkview.haml" : "lib/generators/jinda/templates/app/jinda/template/linkview.haml"
+        gen_view_createfile(sv, f, t)
       end
-      puts $afile.join("\n")
-      puts t.join("\n")
-      return $afile  
     end
+  end
+  Rails.logger.debug $afile.join("\n")
+  Rails.logger.debug t.join("\n")
+  $afile
+end

data/lib/jinda/refresh.rb

@@ -1,67 +1,73 @@
-    def b(s)
-      "<b>#{s}</b>".html_safe
-    end
-    def link_to_blank(body, url_options = {}, html_options = {})
-      link_to(body, url_options, html_options.merge(target: "_blank"))
-    end
-    def code_text(s) # old def code(s)
-      "<pre style='background-color: #efffef;'><code class='ruby' lang='ruby'>#{s}</code></pre>".html_safe
-    end
+# frozen_string_literal: true
 
-    def refresh_to(url='/', option={})
-      if option[:alert]
-        ma_log option[:alert]
-      end
-      # skip # 
-      # Rails 5.2 not allow to use js inline call
-      render inline: "<script>window.location.replace('#{url}')</script>"
-      # redirect_to url
-      # render js: "window.location.replace(\'#{url}\')" 
-    end
+def b(s)
+  "<b>#{s}</b>".html_safe
+end
 
-    # def refresh_to
-    #   respond_to do |format|
-    #     format.js { render :js => "refresh();" }
-    #   end
-    # end
+def link_to_blank(body, url_options = {}, html_options = {})
+  link_to(body, url_options, html_options.merge(target: '_blank'))
+end
 
-    def read_binary(path)
-      File.open path, "rb" do |f| f.read end
-    end
-    def redirect_to_root
-      redirect_to root_path
-    end
+# old def code(s)
+def code_text(s)
+  "<pre style='background-color: #efffef;'><code class='ruby' lang='ruby'>#{s}</code></pre>".html_safe
+end
 
-    # Todo refactor code
-    def get_option(opt, runseq=@runseq)
-      xml= REXML::Document.new(runseq.xml).root
-      url=''
-      # get option from second element of node using '//node'
-      xml.each_element('//node') do |n|
-        if n.attributes['TEXT']
-          text = n.attributes['TEXT']
-          url= text if text =~ /^#{opt}:\s*/
-        end
-      end
-      return nil if url.blank?
-      c, h= url.split(':', 2)
-      opt= h ? h.strip : false
-    end
-    def ma_comment?(s)
-      s[0]==35
-    end
-    def get_ip
-      request.env['HTTP_X_FORWARDED_FOR'] || request.env['REMOTE_ADDR']
-    end
-    def get_default_role
-      default_role= Jinda::Role.where(:code =>'default').first
-      return default_role ? default_role.name.to_s : ''
-    end
+def refresh_to(url = '/', option = {})
+  ma_log option[:alert] if option[:alert]
+  # skip #
+  # Rails 5.2 not allow to use js inline call
+  render inline: "<script>window.location.replace('#{url}')</script>"
+  # redirect_to url
+  # render js: "window.location.replace(\'#{url}\')"
+end
 
-    def sign_in?
-      if current_ma_user.present?
-        return true
-      else
-        return false
-      end
+# def refresh_to
+#   respond_to do |format|
+#     format.js { render :js => "refresh();" }
+#   end
+# end
+
+def read_binary(path)
+  File.binread(path)
+end
+
+def redirect_to_root
+  redirect_to root_path
+end
+
+# Todo refactor code
+def get_option(opt, runseq = @runseq)
+  xml = REXML::Document.new(runseq.xml).root
+  url = ''
+  # get option from second element of node using '//node'
+  xml.each_element('//node') do |n|
+    if n.attributes['TEXT']
+      text = n.attributes['TEXT']
+      url  = text if /^#{opt}:\s*/.match?(text)
     end
+  end
+  return nil if url.blank?
+
+  _, h = url.split(':', 2)
+  opt  = h ? h.strip : false
+end
+
+def ma_comment?(s)
+  s[0] == 35
+end
+
+def get_ip
+  request.env['HTTP_X_FORWARDED_FOR'] || request.env['REMOTE_ADDR']
+end
+
+def get_default_role
+  default_role = Jinda::Role.where(code: 'default').first
+  default_role ? default_role.name.to_s : ''
+end
+
+def sign_in?
+  return true if current_ma_user.present?
+
+  false
+end