mushy 0.21.2 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b74a763b3548295aa4227af27f34e3472f057e9091896ecf0afa45a2e0452dfd
-  data.tar.gz: f5a7f830dea50073856eb0ff645f0904e27f04b546fb6ace2b5f6219d94e31c1
+  metadata.gz: 14c83015994e50fb8e7e866d470f04ecf9eab1fe62d9703ae2057193e4096333
+  data.tar.gz: fbb42092b84fbe6a033796de99eebe42cd4f3a033e7fc64a4d5a52ba9d17637f
 SHA512:
-  metadata.gz: 13a60bf45d09d7d768dab814966301d09ff7156b9c77261af1ec6f27d5e4fb11840f091034be5cd8df2e89e7ef3024503c29640269183e522e75bc8bc1261e5a
-  data.tar.gz: 4fdf85336bcf80cfaf147f2f4e92f1e4a6956ffb9a014b89b04f57faa523c00ec9c7803909b47c10324490d70472b87bcbc063fb0877d6e8d80b333828967d24
+  metadata.gz: 679249c7be4eac1f69d57ebe7df82c4b5d1c7b7b68faaf88744293f1b0519e46e5d6776e0ab0db5d929ec55a47b9b4b197b51d086d3d79be991cbec326a7b85e
+  data.tar.gz: 0a07f13c6d8d0013e0b6ac7d24d81695d12ce3377a71fb3b7501cd09977fb2e0d35c56ac0e9f9411c899309f401e3c695dc21a753b82e177e4052fca98a036bb

data/bin/mushy

@@ -4,7 +4,6 @@ require 'thor'
 require 'mushy'
 
 class MushyCLI < Thor
-
   argument :file, optional: true, type: :string
   argument :values, optional: true, type: :hash
 
@@ -16,29 +15,26 @@ class MushyCLI < Thor
 
   desc "build FILE", 'Build a flow.'
   def build
-
-    MushyCLI.set_special( { method: 'build', file: file } )
-
+    MushyCLI.set_special_values( { method: 'build', file: file } )
   end
 
-  def self.set_special data
+  def self.set_special_values data
     @special = data
   end
 
-  def self.get_special
+  def self.get_special_values
     @special
   end
-
 end
 
 MushyCLI.start(ARGV)
 
-exit unless MushyCLI.get_special
+exit unless MushyCLI.get_special_values
 
 require 'sinatra'
 enable :run
 
-the_file = MushyCLI.get_special[:file]
+the_file = MushyCLI.get_special_values[:file]
 
 get '/' do
   Mushy::Builder::Index.file

data/lib/mushy/builder/api.rb

@@ -1,191 +1,185 @@
 require 'daemons'
 
-module Mushy
+module Mushy::Builder
+end
 
-  module Builder
+module Mushy::Builder::Api
+  def self.run(data)
+    data = SymbolizedHash.new JSON.parse(data)
 
-    module Api
+    event = SymbolizedHash.new JSON.parse(data[:setup][:event].to_json)
 
-      def self.run data
+    config = SymbolizedHash.new data[:config]
 
-        data = SymbolizedHash.new JSON.parse(data)
+    flux = Mushy::Flow.build_flux({ type: data[:setup][:flux], config: config })
 
-        event = SymbolizedHash.new JSON.parse(data[:setup][:event].to_json)
+    result = flux.execute event
 
-        config = SymbolizedHash.new data[:config]
-
-        flux = Mushy::Flow.build_flux( { type: data[:setup][:flux], config: config } )
-
-        result = flux.execute event
-
-        [result].flatten
-      end
-
-      def self.save file, data
-
-        file = "#{file}.mushy" unless file.downcase.end_with?('.mushy')
-
-        data = SymbolizedHash.new JSON.parse(data)
-        Mushy::WriteFile.new.process( {}, { name: file, data: JSON.pretty_generate(data) })
-
-      end
-
-      def self.start file, event
-        original_file = file
-        file = [file, "#{Dir.home}/.mushy/#{file}"]
-               .map { |x| (x.downcase.end_with?('.mushy') ? x : "#{x}.mushy") }
-               .select { |x| File.exist?(x) }
-               .first
-
-        unless file
-          puts "#{original_file} does not exist."
-          return
-        end
-
-        flow = File.open(file).read
-        flow = Mushy::Flow.parse flow
+    [result].flatten
+  end
 
-        service_fluxes = flow.fluxs.select { |x| x.respond_to? :loop }
+  def self.save(file, data)
+    file = "#{file}.mushy" unless file.downcase.end_with?('.mushy')
 
-        pwd = Dir.pwd
+    data = SymbolizedHash.new JSON.parse(data)
+    Mushy::WriteFile.new.process({}, { name: file, data: JSON.pretty_generate(data) })
+  end
 
-        if service_fluxes.any?
+  def self.start(file, event)
+    original_file = file
+    file = [file, "#{Dir.home}/.mushy/#{file}"]
+             .map { |x| (x.downcase.end_with?('.mushy') ? x : "#{x}.mushy") }
+             .select { |x| File.exist?(x) }
+             .first
 
-          things = service_fluxes
-             .map { |s| { flux: s, proc: ->(e) do
-                                                 Dir.chdir pwd
-                                                 Mushy::Runner.new.start e, s, flow
-                                               end,
-                          run_method: (s.config[:run_strategy] == 'daemon' ? :run_this_as_a_daemon : :run_this_inline),
-                        }
-                  }.group_by { |x| x[:run_method] }
+    unless file
+      puts "#{original_file} does not exist."
+      return
+    end
 
-          calls = (things[:run_this_as_a_daemon] || [])
-             .map { |p| ->() { p[:flux].loop &p[:proc] } }
-             .map { |x| ->() { loop &x } }
-             .map { |x| run_this_as_a_daemon &x }
+    flow = File.open(file).read
+    flow = Mushy::Flow.parse flow
 
-          (things[:run_this_inline] || [])
-             .map { |p| ->() { p[:flux].loop &p[:proc] } }
-             .map { |x| ->() { loop &x } }
-             .map { |x| run_this_inline &x }
+    service_fluxes = flow.fluxs.select { |x| x.respond_to? :loop }
 
-          exit
-        end
+    pwd = Dir.pwd
 
-        cli_flux = flow.fluxs.select { |x| x.kind_of?(Mushy::Cli) }.first
+    if service_fluxes.any?
 
-        Mushy::Runner.new.start event, cli_flux, flow
-      end
+      things = service_fluxes
+          .map do |s|
+            {
+              flux: s,
+              proc: lambda do |e|
+                Dir.chdir(pwd)
+                Mushy::Runner.new.start(e, s, flow)
+              end,
+              run_method: (s.config[:run_strategy] == 'daemon' ? :run_this_as_a_daemon : :run_this_inline)
+            }
+          end.group_by { |x| x[:run_method] }
 
-      def self.run_this_inline &block
-        block.call
-      end
+      (things[:run_this_as_a_daemon] || [])
+        .map { |p| -> { p[:flux].loop(&p[:proc]) } }
+        .map { |x| -> { loop(&x) } }
+        .map { |x| run_this_as_a_daemon(&x) }
 
-      def self.run_this_as_a_daemon &block
-        Daemons.call(&block).pid.pid
-      end
+      (things[:run_this_inline] || [])
+        .map { |p| -> { p[:flux].loop(&p[:proc]) } }
+        .map { |x| -> { loop(&x) } }
+        .map { |x| run_this_inline(&x) }
 
-      def self.get_flow file
-        file = "#{file}.mushy" unless file.downcase.end_with?('.mushy')
-        data = JSON.parse File.open(file).read
+      exit
+    end
 
-        data['fluxs'] = standardize_these data['fluxs']
-        data['fluxs'] = organize_as_a_flattened_tree_based_on_parents data['fluxs']
+    cli_flux = flow.fluxs.select { |x| x.is_a?(Mushy::Cli) }.first
 
-        data
-      rescue
-        { fluxs: [] }
-      end
+    Mushy::Runner.new.start event, cli_flux, flow
+  end
 
-      def self.standardize_these fluxs
-        fluxs
-          .reject { |x| x['parents'] }
-          .each   { |x| x['parents'] = [x['parent']].select { |y| y } }
-        fluxs
-          .select { |x| x['parent'] }
-          .each   { |x| x.delete 'parent' }
-        fluxs
-          .select { |x| x['parents'] }
-          .each   { |x| x['parents'] = x['parents'].select { |y| y } }
-
-        fluxs
-      end
+  def self.run_this_inline(&block)
+    block.call
+  end
 
-      def self.organize_as_a_flattened_tree_based_on_parents fluxs
-        fluxs = fluxs.sort_by { |x| x['parents'].count }
+  def self.run_this_as_a_daemon(&block)
+    Daemons.call(&block).pid.pid
+  end
 
-        new_fluxs = [fluxs.first]
+  def self.get_flow(file)
+    file = "#{file}.mushy" unless file.downcase.end_with?('.mushy')
+    data = JSON.parse File.open(file).read
 
-        loop do
+    data['fluxs'] = standardize_these data['fluxs']
+    data['fluxs'] = organize_as_a_flattened_tree_based_on_parents data['fluxs']
 
-          next_fluxs = fluxs.select { |x| x['parents'].include? new_fluxs[-1]['id'] }
+    data
+  rescue
+    { fluxs: [] }
+  end
 
-          unless next_fluxs.any?
-            next_fluxs = [fluxs.reject { |x| new_fluxs.map { |y| y['id'] }.include?(x['id']) }[0]].select { |x| x }
-          end
+  def self.standardize_these(fluxs)
+    fluxs
+      .reject { |x| x['parents'] }
+      .each   { |x| x['parents'] = [x['parent']].select { |y| y } }
+    fluxs
+      .select { |x| x['parent'] }
+      .each   { |x| x.delete 'parent' }
+    fluxs
+      .select { |x| x['parents'] }
+      .each   { |x| x['parents'] = x['parents'].select { |y| y } }
+
+    fluxs
+  end
 
-          new_fluxs = [new_fluxs, next_fluxs].flatten
+  def self.organize_as_a_flattened_tree_based_on_parents(fluxs)
+    fluxs = fluxs.sort_by { |x| x['parents'].count }
 
-          break unless next_fluxs.any?
+    new_fluxs = [fluxs.first]
 
-        end
+    loop do
+      next_fluxs = fluxs.select { |x| x['parents'].include? new_fluxs[-1]['id'] }
 
-        new_fluxs
+      unless next_fluxs.any?
+        next_fluxs = [fluxs.reject { |x| new_fluxs.map { |y| y['id'] }.include?(x['id']) }[0]].select { |x| x }
       end
 
-      def self.get_fluxs
-        {
-          fluxs: Mushy::Flux.all.select { |x| x.respond_to? :details }.select { |x| x.details }.map do |flux|
-                         details = flux.details
-
-                         details[:documentation] = Documentation.build_from details
-
-                         details[:config][:incoming_split] = { type: 'text', shrink: true, description: 'Split an incoming event into multiple events by this key, an each event will be processed independently.', default: '' }
-                         details[:config][:outgoing_split] = { type: 'text', shrink: true, description: 'Split an outgoing event into multiple events by this key.', default: '' }
-                         details[:config][:merge] = { type: 'text', shrink: true, description: 'A comma-delimited list of fields from the event to carry through. Use * to merge all fields.', default: '' }
-                         details[:config][:group] = { type: 'text', shrink: true, description: 'Group events by this key, with the value as the key. If a group key is provided like group_by|group_key, then multiple events with the results under group_key will be returned.', default: '' }
-                         details[:config][:limit] = { type: 'integer', shrink: true, description: 'Limit the number of events to this number.', default: '' }
-                         details[:config][:join] = { type: 'text', shrink: true, description: 'Join all of the events from this flux into one event, under this name.', default: '' }
-                         details[:config][:sort] = { type: 'text', shrink: true, description: 'Sort by this key.', default: '' }
-                         details[:config][:ignore] = { type: 'text', shrink: true, description: 'Ignore these keys.', value: '', default: '' }
-                         details[:config][:model] = { type: 'keyvalue', shrink: true, description: 'Reshape the outgoing events.', value: {}, default: {} }
-
-                         details[:config][:error_strategy] = {
-                           description: 'Error strategy. (return to return an event with "exception" returning the error, or ignore to ignore the exception)',
-                           type:        'select',
-                           options:     ['', 'return', 'ignore'],
-                           value:       '',
-                           shrink:      true,
-                         }
-
-                         if flux.new.respond_to? :loop
-                           details[:config][:run_strategy] = {
-                             description: 'Run this using this strategy. (select "daemon" if this should be run in the background)',
-                             type:        'select',
-                             options:     ['', 'inline', 'daemon'],
-                             value:       '',
-                             shrink:      true,
-                           }
-                         end
-
-                         details[:config]
-                                .select { |_, v| v[:type] == 'keyvalue' }
-                                .select { |_, v| v[:editors].nil? }
-                                .each   do |_, v|
-                                          v[:editors] = [
-                                                    { id: 'new_key', target: 'key', field: { type: 'text', value: '', default: '' } },
-                                                    { id: 'new_value', target: 'value', field: { type: 'text', value: '', default: '' } }
-                                                  ]
-                                  end
-
-                         details
-                 end.sort_by { |x| x[:name] }
-        }
-      end
+      new_fluxs = [new_fluxs, next_fluxs].flatten
 
+      break unless next_fluxs.any?
     end
 
+    new_fluxs
   end
 
-end
+  def self.get_fluxs
+    {
+      fluxs: Mushy::Flux.all
+                        .select { |x| x.respond_to? :details }
+                        .select(&:details)
+                        .map do |flux|
+                          details = flux.details
+
+                          details[:documentation] = Mushy::Builder::Documentation.build_from details
+
+                          details[:config][:incoming_split] = { type: 'text', shrink: true, description: 'Split an incoming event into multiple events by this key, an each event will be processed independently.', default: '' }
+                          details[:config][:outgoing_split] = { type: 'text', shrink: true, description: 'Split an outgoing event into multiple events by this key.', default: '' }
+                          details[:config][:merge] = { type: 'text', shrink: true, description: 'A comma-delimited list of fields from the event to carry through. Use * to merge all fields.', default: '' }
+                          details[:config][:group] = { type: 'text', shrink: true, description: 'Group events by this key, with the value as the key. If a group key is provided like group_by|group_key, then multiple events with the results under group_key will be returned.', default: '' }
+                          details[:config][:limit] = { type: 'integer', shrink: true, description: 'Limit the number of events to this number.', default: '' }
+                          details[:config][:join] = { type: 'text', shrink: true, description: 'Join all of the events from this flux into one event, under this name.', default: '' }
+                          details[:config][:sort] = { type: 'text', shrink: true, description: 'Sort by this key.', default: '' }
+                          details[:config][:ignore] = { type: 'text', shrink: true, description: 'Ignore these keys.', value: '', default: '' }
+                          details[:config][:model] = { type: 'keyvalue', shrink: true, description: 'Reshape the outgoing events.', value: {}, default: {} }
+
+                          details[:config][:error_strategy] = {
+                            description: 'Error strategy. (return to return an event with "exception" returning the error, or ignore to ignore the exception)',
+                            type: 'select',
+                            options: ['', 'return', 'ignore'],
+                            value: '',
+                            shrink: true
+                          }
+
+                          if flux.new.respond_to? :loop
+                            details[:config][:run_strategy] = {
+                              description: 'Run this using this strategy. (select "daemon" if this should be run in the background)',
+                              type: 'select',
+                              options: ['', 'inline', 'daemon'],
+                              value: '',
+                              shrink: true
+                            }
+                          end
+
+                          details[:config]
+                            .select { |_, v| v[:type] == 'keyvalue' }
+                            .select { |_, v| v[:editors].nil? }
+                            .each do |_, v|
+                              v[:editors] = [
+                                { id: 'new_key', target: 'key', field: { type: 'text', value: '', default: '' } },
+                                { id: 'new_value', target: 'value', field: { type: 'text', value: '', default: '' } }
+                              ]
+                            end
+
+                          details
+                        end.sort_by { |x| x[:name] }
+    }
+  end
+end

data/lib/mushy/builder/index.rb

@@ -479,6 +479,7 @@ module Mushy
                                       Vue.set(app.results, 'errorMessage', '');
                                       var the_setup = thingToData(app.setup);
                                       the_setup.event = c.test_event;
+                                      c['_test_mode'] = true;
                                       axios.post('/run', { config: c, setup: the_setup })
                                        .then(function(r){
                                            Vue.set(app.setup.testResultModal, 'is-active', true);

data/lib/mushy/flux.rb

@@ -63,7 +63,8 @@ module Mushy
       the_original_join = mashed_config[:join]
       mashed_config[:join] = nil if mashed_config[:incoming_split]
 
-      results = process event, mashed_config
+      method = config[:_test_mode] && respond_to?(:test) ? :test : :process
+      results = send(method, event, mashed_config)
 
       returned_one_result = results.is_a?(Hash)
 

data/lib/mushy/fluxs/bash.rb

@@ -1,66 +1,58 @@
-module Mushy
-  
-  class Bash < Flux
-
-    def self.details
-      {
-        name: 'Bash',
-        title: 'Execute a command via bash',
-        description: 'Run a bash command.',
-        fluxGroup: { name: 'Execute' },
-        config: {
-          command: {
-                     description: 'The command to run in bash.',
-                     type:        'text',
-                     value:       '{{command}}',
-                   },
-          directory: {
-                       description: 'The working directory in which the command will be run.',
-                       type:        'text',
-                       shrink:      true,
-                       value:       '',
-                     },
+class Mushy::Bash < Mushy::Flux
+  def self.details
+    {
+      name: 'Bash',
+      title: 'Execute a command via bash',
+      description: 'Run a bash command.',
+      fluxGroup: { name: 'Execute' },
+      config: {
+        command: {
+          description: 'The command to run in bash.',
+          type: 'text',
+          value: '{{command}}'
+        },
+        directory: {
+          description: 'The working directory in which the command will be run.',
+          type: 'text',
+          shrink: true,
+          value: ''
+        }
+      },
+      examples: {
+        'Successful Call' => {
+          description: 'This will run the ls command and return the full bash result.',
+          input: { command: 'ls' },
+          result: {
+            text: "bin\nblue_heart.png\nthe_output.txt\n",
+            success: true,
+            exit_code: 0
+          }
         },
-        examples: {
-          "Successful Call" => {
-                             description: 'This will run the ls command and return the full bash result.',
-                             input: {
-                                      command: "ls",
-                                    },
-                             result: {
-                                       "text": "bin\nblue_heart.png\nthe_output.txt\n",
-                                       "success": true,
-                                       "exit_code": 0
-                                     }
-                           },
-          "Failed Call" => {
-                             description: 'This is an example of what happens when the command fails.',
-                             input: { command: 'rm file_that_does_not_exist.txt' },
-                             result: {
-                                       "text": "",
-                                       "success": false,
-                                       "exit_code": 256
-                                     }
-                           },
+        'Failed Call' => {
+          description: 'This is an example of what happens when the command fails.',
+          input: { command: 'rm file_that_does_not_exist.txt' },
+          result: {
+            text: '',
+            success: false,
+            exit_code: 256
           }
+        }
       }
-    end
-
-    def process event, config
-      command = config[:command]
+    }
+  end
 
-      command = "cd #{config[:directory]};#{command}" if config[:directory]
+  def process(_, config)
+    command = config[:command]
 
-      text = `#{command}`
+    command = "cd #{config[:directory]};#{command}" if config[:directory]
 
-      result = $?
-      {
-        text: text,
-        success: result.success?,
-        exit_code: result.to_i,
-      }
-    end
+    text = `#{command}`
 
+    result = $?
+    {
+      text: text,
+      success: result.success?,
+      exit_code: result.to_i
+    }
   end
-
-end
+end