hmx_client 0.0.7 → 0.1.0

data/lib/hmx/command/bootstrap.rb

@@ -1,18 +1,18 @@
-require "hmx/command/base"
-require 'date'
-
-module HmxClient::Command
-
-  # Bootstrap a default configuration
-  #
-  class Bootstrap < Base
-
-    # bootstrap
-    #
-    # Bootstrap a default configuration into this partition
-    def index
-     hmx.bootstrap
-     puts "Done."
-    end
- end
-end
+require "hmx/command/base"
+require 'date'
+
+module HmxClient::Command
+
+  # Bootstrap a default configuration
+  #
+  class Bootstrap < Base
+
+    # bootstrap
+    #
+    # Bootstrap a default configuration into this partition
+    def index
+     hmx.doBootstrap([])
+     puts "Done."
+    end
+ end
+end

data/lib/hmx/command/check.rb

@@ -0,0 +1,170 @@
+require "hmx/command/base"
+
+module HmxClient::Command
+
+  # Provides the ability to check view functions locally
+  #
+  class Check < Base
+
+    # check 
+    #
+    # Download an environment to check 
+    # <folderName> <type>
+    #
+    # Creates <folderName>/functions/[function files that are Ruby]
+    # And <folderName>/<typeName>/[files corresponding to the documents in that type]
+    #
+    def index
+      unless args.size > 1 
+        raise CommandFailed, "Usage: hmx check <folderName> <typeName>" 
+      end
+      rootFolder = args.shift;
+      typeName = args.shift;
+      Dir.mkdir(rootFolder) if !Dir.exist?(rootFolder)
+      fnFolder = rootFolder + '/function/'
+      Dir.mkdir(fnFolder) if !Dir.exist?(fnFolder)
+      displayNames = hmx.doQuery(['sys.fn',nil])
+      displayNames.each { | displayName | 
+              fnInfo = hmx.doGetData([displayName])
+              if fnInfo['document']['MXFunction']['fnLang'] == 'RUBY'
+                 puts "Writing function  - #{ displayName }"
+                 outfile = fnFolder + fnInfo['document']['MXFunction']['fnName'] + '.rb'
+                 File.open(outfile, 'w') { | f | f.write(fnInfo['document']['MXFunction']['content']) }  
+              end
+      }
+     # Now do types
+     typeFolder = rootFolder + '/' + typeName
+     Dir.mkdir(typeFolder) if !Dir.exist?(typeFolder)
+     displayNames = hmx.doQuery([typeName, nil])
+     displayNames.each { | displayName | 
+               document = hmx.doGetData([displayName])
+               outfile = rootFolder + '/' + displayName
+               puts "Writing #{ typeName } - #{ displayName }"
+               File.open(outfile, 'w') { | f | f.write(JSON.pretty_generate(document)) }
+     } 
+    end
+
+    #
+    # check:save
+    #
+    # Given a check function, runs that function against all documents, outputting the value
+    # If the third parameter is given that is an option, to pick one doc (ONE), just display part
+    # PART, or FULL for everything.
+    #
+    # <folder> <fnName> <typeName> [ONE|PART|FULL]
+    def checkSave
+      unless args.size > 1
+        raise CommandFailed, 'Usage: hmx check:save <folderName> <checkfn> <typeName> <ONE|PART|FULL>'
+      end
+      @rootFolder = args.shift
+      fnName = args.shift
+      typeName = args.shift
+      option = 'FULL'
+      if args.size > 0
+       option = args.shift
+      end 
+
+      # What we do here is this
+      # Create an eval string of
+      # 
+      content = getFn(fnName)
+      Evaluator.class_eval(content)
+
+      # Now get the data object
+      typeFolder = "#{@rootFolder}/#{typeName}"
+      ev = Evaluator.new(@rootFolder)
+      res = []
+      Dir.foreach(typeFolder) { | f |
+	          display "Testing #{f}"
+                  fullFile = File.expand_path("#{typeFolder}/#{f}")
+                  if (File.file?(fullFile))  
+                          data = getData(fullFile)
+     	                  res << ev.check(data) 
+                  end
+      }
+      display_tab(res)
+    end
+    # check:view
+    #
+    # Given a folder, a type, a filter fn and a map fn, and a set of parameters to the view
+    # run the view "locally" in this environment, by evaluating the filter and map against
+    # each document downloaded for the type
+
+    def checkView
+      unless args.size > 3
+        raise CommandFailed, "Usage: hmx check:view <folderName> <typeName> <filter> <map> <paramString>"
+      end
+      @rootFolder = args.shift
+      typeName = args.shift
+      filterFn = args.shift
+      mapFn = args.shift
+      paramString = args.shift
+      paramString = JSON.parse(paramString)
+
+      filterContent = getFn(filterFn)
+      mapContent = getFn(mapFn)
+      Evaluator.class_eval(filterContent)
+      Evaluator.class_eval(mapContent)
+      ev = Evaluator.new(@rootFolder)
+      res = []
+      typeFolder = "#{@rootFolder}/#{typeName}/"
+      Dir.foreach(typeFolder) { | f |
+                  fullFile = File.expand_path("#{typeFolder}/#{f}")
+                  if (File.file?(fullFile))  
+                          data = getData(fullFile)
+     	                  val = ev.runView(data, paramString) 
+                          if (!val.nil?)
+                             res << val
+                          end
+                  end
+      }
+      display_tab res
+    end
+
+    protected
+ 
+    def getContent(fileName)
+        File.open(fileName) { | h |
+        c = ''
+        while(line = h.gets)
+             c = c + line
+        end
+        c
+        }
+    end    
+
+    def getFn(fnName)
+      fnFile = @rootFolder + "/function/#{fnName}.rb"
+      getContent(fnFile)
+    end
+    
+    def getData(fileName)
+       JSON.parse(getContent(fileName))
+    end
+ end
+
+ # This is where we'll put the helper functions ($Helper.doGetData)
+ class ScriptHelper
+     def initialize(rootFolder)
+        @rootFolder = rootFolder
+     end
+
+     def getDataAsMap(displayName)
+        { "data" => @rootFolder }
+     end
+ end
+
+ class Evaluator
+      def initialize(rootFolder)
+        $helper = ScriptHelper.new(rootFolder)
+      end
+
+      def runView(data, params)
+          if (filter(data, params))
+             map(data, params)
+          else
+             nil
+          end
+      end
+ end
+end

data/lib/hmx/command/clone.rb

@@ -1,77 +1,77 @@
-require "hmx/command/base"
-require 'date'
-
-module HmxClient::Command
-
-  # Clone a partition or setup a partition from a clone
-  #
-  class Clone < Base
-
-    # clone
-    #
-    # Create a clone file for the current partition
-    def index
-      # Clone the type information
-      # Clone these built in types (i.e. the content)
-      # Clone other types as defined by the command line
-      extraTypes = args
-      types = [ 'sys.user', 'sys.config', 'sys.ent', 'sys.egroup', 'sys.trigger', 'sys.view' ]
-      extraTypes.each { | et | types << et }
-      types.each { | t | dumpTypeAndData(t) }
-    end
-
-    # clone:load
-    #
-    # Load a file that was created using hmx clone
-    # The file basically contains a series of types (documents separated by << >>)
-    # and data (separated by [[ ]])
-    def load
-	# We define the file as being the input file on the command line (--file-in)
-        if (HmxClient::Command.fileIn.nil?)
-           raise CommandFailed, "Usage: hmx clone:load --file-in=<filename>"
-        end
-        realFile = File.expand_path(HmxClient::Command.fileIn)
-        File.open(realFile, 'r') { | f | 
-                                 currentDoc = ''
-                                 isType = false
-                                 while(line = f.gets)
-                                    if (line[0] == '#') 
-                                    elsif (line[0] == '<' && line[1] == '<') 
-				       currentDoc = ''
-                                       isType = true
-                                    elsif (line[0] == '>' && line[1] == '>')
-                                       if isType
-                                          print '.'
-                                          hmx.updateType(JSON.parse(currentDoc))
-                                       end
-                                       currentDoc = ''
-                                    elsif (line[0] == '[' && line[1] == '[')
-                                       currentDoc = ''
-                                       isType = false
-                                    elsif (line[0] == ']' && line[1] == ']')
-                                       if (!isType)
-                                           print 'x'
-                                           hmx.putData([currentDoc])
-                                       end
-                                       currentDoc = ''
-                                    else
-                                       currentDoc = currentDoc + line
-                                    end 
-                                end
-                          }
-         puts ""
-         puts "Done"
-    end 
-
-protected 
-    def dumpTypeAndData(typeName)
-      puts "####### #{ typeName }  "
-      puts "<<"
-      puts JSON.generate(hmx.getType(typeName)) 
-      puts ">>"
-      puts "####### Data for #{ typeName } "
-      displayNames = hmx.query(typeName, nil)
-      displayNames.each { | d | puts("[["); puts JSON.generate(hmx.getData([d])); puts("]]") }
-    end
-  end
-end
+require "hmx/command/base"
+require 'date'
+
+module HmxClient::Command
+
+  # Clone a partition or setup a partition from a clone
+  #
+  class Clone < Base
+
+    # clone
+    #
+    # Create a clone file for the current partition
+    def index
+      # Clone the type information
+      # Clone these built in types (i.e. the content)
+      # Clone other types as defined by the command line
+      extraTypes = args
+      types = [ 'sys.user', 'sys.config', 'sys.ent', 'sys.egroup', 'sys.trigger', 'sys.view' ]
+      extraTypes.each { | et | types << et }
+      types.each { | t | dumpTypeAndData(t) }
+    end
+
+    # clone:load
+    #
+    # Load a file that was created using hmx clone
+    # The file basically contains a series of types (documents separated by << >>)
+    # and data (separated by [[ ]])
+    def load
+	# We define the file as being the input file on the command line (--file-in)
+        if (HmxClient::Command.fileIn.nil?)
+           raise CommandFailed, "Usage: hmx clone:load --file-in=<filename>"
+        end
+        realFile = File.expand_path(HmxClient::Command.fileIn)
+        File.open(realFile, 'r') { | f | 
+                                 currentDoc = ''
+                                 isType = false
+                                 while(line = f.gets)
+                                    if (line[0] == '#') 
+                                    elsif (line[0] == '<' && line[1] == '<') 
+				       currentDoc = ''
+                                       isType = true
+                                    elsif (line[0] == '>' && line[1] == '>')
+                                       if isType
+                                          print '.'
+                                          hmx.doUpdateType([JSON.parse(currentDoc)])
+                                       end
+                                       currentDoc = ''
+                                    elsif (line[0] == '[' && line[1] == '[')
+                                       currentDoc = ''
+                                       isType = false
+                                    elsif (line[0] == ']' && line[1] == ']')
+                                       if (!isType)
+                                           print 'x'
+                                           hmx.doPutData([currentDoc])
+                                       end
+                                       currentDoc = ''
+                                    else
+                                       currentDoc = currentDoc + line
+                                    end 
+                                end
+                          }
+         puts ""
+         puts "Done"
+    end 
+
+protected 
+    def dumpTypeAndData(typeName)
+      puts "####### #{ typeName }  "
+      puts "<<"
+      puts JSON.generate(hmx.doGetType([typeName])) 
+      puts ">>"
+      puts "####### Data for #{ typeName } "
+      displayNames = hmx.doQuery([typeName, nil])
+      displayNames.each { | d | puts("[["); puts JSON.generate(hmx.doGetData([d])); puts("]]") }
+    end
+  end
+end

data/lib/hmx/command/config.rb

@@ -1,67 +1,67 @@
-require "hmx/command/base"
-
-module HmxClient::Command
-
-  # Manage app config vars
-  #
-  class Config < Base
-
-    # config
-    #
-    # display the config vars for an app
-    #
-    # -s, --shell  # output config vars in shell format
-    #
-    def index
-      display_vars(@config, :long => true, :shell => false)
-    end
-
-    # config:add KEY1=VALUE1 ...
-    #
-    # add one or more config vars
-    #
-    def add
-      unless args.size > 0 and args.all? { |a| a.include?('=') }
-        raise CommandFailed, "Usage: hmx config:add <key>=<value> [<key2>=<value2> ...]"
-      end
-
-      args.inject({}) do |vars, arg|
-        key, value = arg.split('=', 2)
-        storeConfig(key.to_sym,value)
-      end
-
-      display_vars(@config, :indent => 2)
-    end
-
-    # config:remove KEY1 [KEY2 ...]
-    #
-    # remove a config var
-    #
-    def remove
-      raise CommandFailed, "Usage: hmx config:remove KEY1 [KEY2 ...]" if args.empty?
-
-      args.each do |key|
-	removeConfig(key.to_sym)
-        display_vars(@config, :indent => 2)
-      end
-    end
-
-    protected
-      def display_vars(vars, options={})
-        max_length = vars.map { |v| v[0].to_s.size }.max
-        vars.keys.sort.each do |key|
-          if options[:shell]
-            display "#{key}=#{vars[key]}"
-          else
-            spaces = ' ' * (max_length - key.to_s.size)
-            display "#{' ' * (options[:indent] || 0)}#{key}#{spaces} => #{format(vars[key], options)}"
-          end
-        end
-      end
-
-      def format(value, options)
-        return value if options[:long] || value.to_s.size < 36
-        value[0, 16] + '...' + value[-16, 16]
-      end
-  end
-end
+require "hmx/command/base"
+
+module HmxClient::Command
+
+  # Manage app config vars
+  #
+  class Config < Base
+
+    # config
+    #
+    # display the config vars for an app
+    #
+    # -s, --shell  # output config vars in shell format
+    #
+    def index
+      display_vars(@config, :long => true, :shell => false)
+    end
+
+    # config:add KEY1=VALUE1 ...
+    #
+    # add one or more config vars
+    #
+    def add
+      unless args.size > 0 and args.all? { |a| a.include?('=') }
+        raise CommandFailed, "Usage: hmx config:add <key>=<value> [<key2>=<value2> ...]"
+      end
+
+      args.inject({}) do |vars, arg|
+        key, value = arg.split('=', 2)
+        storeConfig(key.to_sym,value)
+      end
+
+      display_vars(@config, :indent => 2)
+    end
+
+    # config:remove KEY1 [KEY2 ...]
+    #
+    # remove a config var
+    #
+    def remove
+      raise CommandFailed, "Usage: hmx config:remove KEY1 [KEY2 ...]" if args.empty?
+
+      args.each do |key|
+	removeConfig(key.to_sym)
+        display_vars(@config, :indent => 2)
+      end
+    end
+
+    protected
+      def display_vars(vars, options={})
+        max_length = vars.map { |v| v[0].to_s.size }.max
+        vars.keys.sort.each do |key|
+          if options[:shell]
+            display "#{key}=#{vars[key]}"
+          else
+            spaces = ' ' * (max_length - key.to_s.size)
+            display "#{' ' * (options[:indent] || 0)}#{key}#{spaces} => #{format(vars[key], options)}"
+          end
+        end
+      end
+
+      def format(value, options)
+        return value if options[:long] || value.to_s.size < 36
+        value[0, 16] + '...' + value[-16, 16]
+      end
+  end
+end