mushy 0.0.1

data/lib/mushy/fluxs/collection.rb

@@ -0,0 +1,73 @@
+module Mushy
+
+  class Collection < Flux
+
+    attr_accessor :collection
+
+    def self.details
+      {
+        name: 'Collection',
+        description: 'Collects events.',
+        config: {
+          id: {
+                description: 'The path to the unique id in the body of the element.',
+                type: 'id',
+                value: { url: 'a|@href' },
+              },
+          operation: {
+                       description: 'Perform this operation.',
+                       type:        'select',
+                       options:     ['all', 'delete', 'upsert', 'update', 'insert'],
+                       value:       'upsert',
+                     },
+        },
+      }
+    end
+
+    def initialize
+      self.collection = {}
+      super
+    end
+
+    def process event, config
+      self.send(config[:operation].to_sym, event, config)
+    end
+
+    def get_the_id event, config
+      event[config[:id]]
+    end
+
+    def all event, config
+      self.collection.values
+    end
+
+    def delete event, config
+      self.collection.delete get_the_id(event, config)
+      event[config[:operation_performed]] = 'deleted' if config[:operation_performed]
+      event
+    end
+
+    def upsert event, config
+      if self.collection[get_the_id(event, config)]
+        update event, config
+      else
+        insert event, config
+      end
+    end
+
+    def update event, config
+      item = self.collection[get_the_id(event, config)]
+      event.each { |k, v| item[k] = v } if item
+      event[config[:operation_performed]] = (item ? 'updated' : 'not exist') if config[:operation_performed]
+      event
+    end
+
+    def insert event, config
+      self.collection[get_the_id(event, config)] = event
+      event[config[:operation_performed]] = 'inserted' if config[:operation_performed]
+      event
+    end
+
+  end
+
+end

data/lib/mushy/fluxs/filter.rb

@@ -0,0 +1,37 @@
+module Mushy
+  
+  class Filter < Flux
+
+    def process event, config
+
+      differences = [:equal, :notequal]
+        .select { |x| config[x].is_a? Hash }
+        .map { |x| config[x].map { |k, v| { m: x, k: k, v1: v } } }
+        .flatten
+        .map { |x| x[:v2] = event[x[:k]] ; x }
+        .map { |x| [x[:m], x[:v1], x[:v2]] }
+        .reject { |x| self.send x[0], x[1], x[2] }
+
+      differences.count == 0 ? event : nil
+
+    end
+
+    def equal a, b
+      [a, b]
+        .map { |x| numeric?(x) ? x.to_f : x }
+        .map { |x| x.to_s.strip.downcase }
+        .group_by { |x| x }
+        .count == 1
+    end
+
+    def notequal a, b
+      equal(a, b) == false
+    end
+
+    def numeric? value
+      Float(value) != nil rescue false
+    end
+
+  end
+
+end

data/lib/mushy/fluxs/get.rb

@@ -0,0 +1,30 @@
+require 'faraday'
+
+module Mushy
+  
+  class Get < Flux
+
+    def process event, config
+
+      faraday = Faraday.new do |connection|
+        connection.adapter Faraday.default_adapter
+      end
+
+      headers = config[:headers] || {}
+      data = {}
+      url = config[:url]
+
+      response = faraday.get config[:url], data, headers
+
+      {
+        status: response.status,
+        url: url,
+        reason_phrase: response.reason_phrase,
+        headers: response.headers,
+        body: response.body,
+      }
+    end
+
+  end
+
+end

data/lib/mushy/fluxs/ls.rb

@@ -0,0 +1,38 @@
+module Mushy
+
+  class Ls < Bash
+
+    def self.details
+      {
+        name: 'Ls',
+        description: 'Run the "ls" command.',
+        config: {
+          directory: {
+                       description: 'The working directory in which the command will be run.',
+                       type:        'text',
+                       value:       '',
+                     },
+        },
+      }
+    end
+
+    def process event, config
+
+      config[:command] = 'ls'
+
+      result = super event, config
+
+      return result unless result[:success]
+
+      result[:text].split("\n").map do |x|
+        {
+          name: x,
+        }
+      end
+
+    end
+
+  end
+
+end
+

data/lib/mushy/fluxs/parse_html.rb

@@ -0,0 +1,52 @@
+require 'nokogiri'
+
+module Mushy
+  
+  class ParseHtml < Flux
+
+    def self.details
+      {
+        name: 'ParseHtml',
+        description: 'Parses HTML.',
+        config: {
+          path: {
+                  description: 'The path to the HTML in the incoming event.',
+                  type:        'text',
+                  value:       'body',
+                },
+          extract: {
+                     description: 'The form of the event that is meant to be pulled from this event.',
+                     type: 'keyvalue',
+                     value: { url: 'a|@href' },
+                   }
+        },
+      }
+    end
+
+    def process event, config
+
+      doc = Nokogiri::HTML event[config[:path]]
+
+      matches = config[:extract].keys.reduce( { } ) do |matches, key|
+        css, value = config[:extract][key].split('|')
+        value = value || './node()'
+
+        matches[key] = doc.css(css).map { |x| x.xpath(value).to_s }
+        matches
+      end
+
+      matches[matches.keys.first]
+         .each_with_index
+         .map { |_, i| i }
+         .map do |i|
+                matches.keys.reduce(SymbolizedHash.new( { } )) do |record, key|
+                  record[key] = matches[key][i]
+                  record[key] = record[key].strip if record[key]
+                  record
+                end
+              end
+    end
+
+  end
+
+end

data/lib/mushy/fluxs/read_csv.rb

@@ -0,0 +1,27 @@
+require 'csv'
+
+module Mushy
+  
+  class ReadCsv < Flux
+
+    def process event, config
+      data = event[config[:key]]
+
+      headers = config[:headers].to_s.strip.downcase == 'true' ? true : false
+
+      rows = CSV.new data, headers: headers
+
+      rows.map do |row|
+        if headers
+          row.to_hash
+        else
+          record = {}
+          row.each_with_index { |r, i| record[("a".ord + i).chr] = r }
+          record
+        end
+      end
+    end
+
+  end
+
+end

data/lib/mushy/fluxs/write_file.rb

@@ -0,0 +1,39 @@
+module Mushy
+
+  class WriteFile < Flux
+
+    def self.details
+      {
+        name: 'WriteFile',
+        description: 'Write a file.',
+        config: {
+          name: {
+                  description: 'The name of the file.',
+                  type:        'text',
+                  value:       'records',
+                },
+          directory: {
+                  description: 'The directory in which to write the file. Leave blank for the current directory.',
+                  type:        'text',
+                  value:       'records',
+                },
+          path: {
+                  description: 'The path to the data to write.',
+                  type:        'text',
+                  value:       'records',
+                },
+        },
+      }
+    end
+
+    def process event, config
+      data = event[config[:path].to_sym] || event[config[:path].to_s]
+
+      File.open(config[:name], 'w') { |f| f.write data }
+
+      {}
+    end
+
+  end
+
+end

data/lib/mushy/masher.rb

@@ -0,0 +1,56 @@
+module Mushy
+
+  class Masher
+
+    attr_accessor :mash_methods
+
+    def initialize
+      self.mash_methods = 
+        {
+          String => ->(x, d) do
+                               x.match('{{\s?(\w*)\s?}}') do |m|
+                                 if (m.captures.count == 1)
+                                   match_on_key = d.keys.select { |x| x.to_s == m.captures[0].to_s }.first
+                                   if match_on_key
+                                     value = dig match_on_key.to_s, d
+                                     return value unless value.is_a?(String) || value.is_a?(Numeric)
+                                   end
+                                 end
+                               end
+                               Liquid::Template.parse(x).render SymbolizedHash.new(d)
+                             end,
+          Hash   => ->(x, d) do
+                               h = SymbolizedHash.new(x)
+                               h.each { |k, v| h[k] = mash v, d }
+                               h
+                             end,
+          Array  => ->(x, d) { x.map { |x| mash x, d } }
+        }
+    end
+
+    def mash value, data
+      method_for(value).call value, data
+    end
+
+    def method_for value
+      mash_methods
+        .select { |k, _| value.is_a? k }
+        .map    { |_, v| v }
+        .first || ->(x, _) { x }
+    end
+
+    def dig key, data
+      return nil unless key
+
+      segments = key.split '.'
+
+      segments.each do |segment|
+        data = data.is_a?(Hash) ? (data[segment] || data[segment.to_sym]) : (data ? data.send(segment.to_sym) : nil)
+      end
+
+      data
+    end
+
+  end
+
+end

data/lib/mushy/run.rb

@@ -0,0 +1,8 @@
+module Mushy
+
+  class Run
+    attr_accessor :id
+    attr_accessor :flow_id
+  end
+
+end

data/lib/mushy/runner.rb

@@ -0,0 +1,56 @@
+module Mushy
+
+  class Runner
+
+    attr_accessor :runner
+
+    def initialize runner = nil
+      self.runner = runner || self
+    end
+
+    def start event_data, flux, flow
+      run = find_run flux, flow
+      starting_event = build_event event_data, flow.id, run.id, flux.id
+
+      events = run_event_with_flux starting_event, flux
+
+      while events.any?
+        events = events.map { |e| runner.run_event_in_flow e, flow }.flatten
+      end
+
+      run
+    end
+
+    def run_event_in_flow event, flow
+      flow.fluxs_for(event)
+        .map { |s| runner.run_event_with_flux event, s }
+        .flatten
+    end
+
+    def run_event_with_flux event, flux
+      [flux.execute(event.data)]
+        .flatten
+        .reject { |x| x.nil? }
+        .map { |x| x.is_a?(Hash) ? build_event(x, event.flow_id, event.run_id, flux.id) : x }
+    end
+
+    def find_run flux, flow
+      run = Mushy::Run.new
+      run.id = SecureRandom.uuid
+      run.flow_id = flow.id
+      run
+    end
+
+    def build_event event_data, flow_id, run_id, flux_id
+      event = Mushy::Event.new
+      event.id = SecureRandom.uuid
+      event.run_id = run_id
+      event.flow_id = flow_id
+      event.flux_id = flux_id
+      event.data = event_data
+      event
+    end
+
+  end
+
+end

data/lib/mushy/version.rb

@@ -0,0 +1,3 @@
+module Mushy
+  VERSION = '0.0.1'
+end

data/lib/public/index.html

@@ -0,0 +1,256 @@
+<html>
+    <head>
+        <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/water.css@2/out/dark.css">
+        <script src="https://cdn.jsdelivr.net/npm/vue@2.6.12/dist/vue.js"></script>
+        <script src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
+    </head>
+    <body>
+        <div id="app">
+            <table>
+                <tr v-for="flux in flow.fluxs">
+                    <td>{{flux.name}}</td>
+                </tr>
+            </table>
+            <mip-heavy :data="setup"></mip-heavy>
+            <mip-heavy v-for="(data, id) in configs" v-show="setup.flux.value === id" :data="data"></mip-heavy>
+            <div v-if="results.loading">Loading...</div>
+            <div v-else>{{results.length}} result{{results.length == 1 ? "" : "s"}}</div>
+            <mip-heavy v-for="data in results" :data="data"></mip-heavy>
+        </div>
+    </body>
+</html>
+
+<script type="text/javascript">
+
+   var fancyName = function(id) { return '(' + id + '.split(/[ _]/).map(function(x){return x[0].toUpperCase() + x.substring(1)}).join(\' \'))' };
+   var thingToData = function(thing) {
+                         var record = {};
+                         for (var key in thing)
+                             if (thing[key].value)
+                                 if (thing[key].type == 'json')
+                                     record[key] = JSON.parse(thing[key].value);
+                                 else
+                                     record[key] = thing[key].value;
+                         return record;
+                     };
+
+   var components = {
+       label: {
+           props: ['label', 'description'],
+           template: '<label :for="id" v-if="label != \'\'">{{label || ' + fancyName('id') + '}} <i v-show="description">({{description}})</i></label>'
+       },
+       text:  {
+           props: ['label', 'placeholder', 'disabled', 'readonly', 'value', 'description'],
+           template: '<div><mip-label :id="id" :label="label" :description="description"></mip-label><input type="text" :name="id" :placeholder="placeholder" v-bind:value="value" v-on:input="$emit(\'update:value\', $event.target.value);" :disabled="disabled == \'true\'" :readonly="readonly == \'true\'"></div>'
+       },
+       integer:  {
+           props: ['label', 'placeholder', 'disabled', 'readonly', 'value', 'description'],
+           template: '<div><mip-label :id="id" :label="label" :description="description"></mip-label><input type="text" :name="id" :placeholder="placeholder" v-bind:value="value" v-on:input="$emit(\'update:value\', $event.target.value);" :disabled="disabled == \'true\'" :readonly="readonly == \'true\'"></div>'
+       },
+       email: {
+           props: ['label', 'placeholder', 'disabled', 'readonly', 'value', 'description'],
+           template: '<div><mip-label :id="id" :label="label" :description="description"></mip-label><input type="email" :name="id" :placeholder="placeholder" v-bind:value="value" v-on:input="$emit(\'update:value\', $event.target.value)" :disabled="disabled == \'true\'" :readonly="readonly == \'true\'"></div>'
+       },
+       textarea: {
+           props: ['label', 'placeholder', 'disabled', 'readonly', 'value', 'description'],
+           template: '<div><mip-label :id="id" :label="label" :description="description"></mip-label><textarea :name="id" :placeholder="placeholder" v-bind:value="value" v-on:input="$emit(\'update:value\', $event.target.value)" :disabled="disabled == \'true\'" :readonly="readonly == \'true\'"></textarea></div>'
+       },
+       json: {
+           props: ['label', 'placeholder', 'disabled', 'readonly', 'value', 'description'],
+           template: '<div><mip-label :id="id" :label="label" :description="description"></mip-label><pre><code>{{value}}</code></pre><textarea :name="id" :placeholder="placeholder" v-bind:value="value" v-on:input="$emit(\'update:value\', $event.target.value)" :disabled="disabled == \'true\'" :readonly="readonly == \'true\'"></textarea></div>'
+       },
+       jsonview: {
+           data: function() {
+               return {
+                   toggle: function(view) { return view == 'beautiful' ? 'thin' : 'beautiful'; },
+                   copy: function(view, json) { console.log(view); return navigator.clipboard.writeText((view == 'beautiful' ? JSON.stringify(json, null, "  ") : JSON.stringify(json))); },
+                   show: function(view, json) { return view == 'beautiful' ? JSON.stringify(json, null, "  ") : JSON.stringify(json); },
+               };
+           },
+           props: ['label', 'placeholder', 'disabled', 'readonly', 'value', 'description', 'view'],
+           template: '<div><mip-label :id="id" :label="label" :description="description"></mip-label> <a href="#" v-on:click.prevent.stop="view=toggle(view)">{{(view == \'beautiful\' ? \'>\' : \'^\')}}</a><a href="#" v-on:click.prevent.stop="copy(view, value)">copy</a><pre><code>{{show(view, value)}}</code></pre></div>'
+       },
+       radio: {
+           props: ['label', 'value', 'options', 'description'],
+           template: '<div><mip-label :id="id" :label="label" :description="description"></mip-label><div v-for="option in options"><input type="radio" :name="id" v-bind:value="option" v-on:input="$emit(\'update:value\', $event.target.value)" :checked="value == option"> <label for="option">{{option}}</label></div></div>'
+       },
+       select: {
+           props: ['label', 'value', 'options', 'description'],
+           template: '<div><mip-label :id="id" :label="label" :description="description"></mip-label><select :name="id" v-on:input="$emit(\'update:value\', $event.target.value)"><option v-for="option in options" v-bind:value="option" :selected="value == option">{{option}}</option></select></div>'
+       },
+       boolean: {
+           props: ['label', 'value', 'options', 'description'],
+           template: '<div><mip-label :id="id" :label="label" :description="description"></mip-label><select :name="id" v-on:input="$emit(\'update:value\', $event.target.value)"><option v-for="option in [true, false]" v-bind:value="option" :selected="value == option">{{option}}</option></select></div>'
+       },
+       table: {
+           props: ['value', 'description'],
+           template: '<table><tr><th v-for="(d, i) in value[0]">{{' + fancyName('i') + '}}</th></tr><tr v-for="v in value"><td v-for="(d, i) in v">{{d}}</td></tr></table>'
+       },
+       editgrid: {
+           data: function() {
+               return {
+                   removeRecord: function(record, records, index) { records.splice(index, 1); },
+                   addRecord: function(editors, records) {
+                                                    var record = {};
+                                                    for (var i = 0; i < editors.length; i++)
+                                                    {
+                                                        record[editors[i].target] = editors[i].field.value;
+                                                        editors[i].field.value = editors[i].field.default ? editors[i].field.default : '';
+                                                    }
+                                                    records.push(record);
+                                                }
+               };
+           },
+           props: ['value', 'editors', 'label', 'description'],
+           template: '<div><mip-label :id="id" :label="label" :description="description"></mip-label><table><tr><th v-for="(d, i) in value[0]">{{' + fancyName('i') + '}}</th></tr><tr v-for="(v, z) in value"><td v-for="(d, i) in v">{{d}}</td><td><a href="#" v-on:click.prevent.stop="removeRecord(v, value, z)">[x]</a></td></tr><tr><td v-for="editor in editors"><mip-thing :data="editor.field" :id="editor.id"></mip-thing></td><td><a href="#" v-on:click.prevent.stop="addRecord(editors, value)">[Add]</a></td></tr></table></div>'
+       },
+       keyvalue: {
+           data: function() {
+               return {
+                   removeRecord: function(data, key) { Vue.delete(data, key) },
+                   addRecord: function(editors, data) {
+                                                   Vue.set(data, editors[0].field.value, editors[1].field.value)
+                                                   editors[0].field.value = editors[0].field.default;
+                                                   editors[1].field.value = editors[1].field.default;
+                                                }
+               };
+           },
+           props: ['value', 'label', 'editors', 'description'],
+           template: '<div><mip-label :id="id" :label="label" :description="description"></mip-label><table><tr v-for="(v, k) in value"><td>{{k}}</td><td>{{v}}</td><td><a href="#" v-on:click.prevent.stop="removeRecord(value, k)">[x]</a></td></tr><tr><td v-for="editor in editors"><mip-thing :data="editor.field" :id="editor.id"></mip-thing></td><td><a href="#" v-on:click.prevent.stop="addRecord(editors, value)" v-show="editors[0].field.value">[Add]</a></td></tr></table></div>'
+       },
+       button: {
+           props: ['click', 'description'],
+           template: '<button v-on:click.prevent.stop="click(pull(this))">{{id}}</button>'
+       }
+   };
+
+   for(var property in components)
+   {
+       var props = JSON.parse(JSON.stringify(components[property].props));
+       props.push('id');
+       Vue.component('mip-' + property, {
+            data: components[property].data ?? function () {
+                      var foundIt = this.$parent;
+                      var counter = 0;
+                      while (foundIt.$parent.constructor.name == "VueComponent" && counter < 10)
+                      {
+                        foundIt = foundIt.$parent;
+                        counter += 1;
+                      }
+                      return {
+                          console: console,
+                          pull: function(x) { return thingToData(foundIt.data); },
+                      }
+                  },
+            props: props,
+            template: components[property].template
+       });
+   }
+
+   var thingTemplate = '<div>';
+   for (var property in components)
+       thingTemplate = thingTemplate + '<mip-' + property + ' v-if="data.type == \'' + property + '\'" :id="id" ' + components[property].props.map(function(x){ return ':' + x + '.sync="data.' + x + '"';}).join(' ') + '></mip-' + property + '>'
+   thingTemplate = thingTemplate + '</div>';
+
+   Vue.component('mip-thing', {
+        data: function () {
+                  return {
+                      console: console,
+                  }
+        },
+        props: ['data', 'value', 'id', 'model'],
+        template: thingTemplate
+    });
+
+   Vue.component('mip-heavy', {
+        data: function () {
+                  return {
+                      console: console,
+                  }
+        },
+        props: ['data'],
+        template: '<div><mip-thing v-for="(d, id) in data" :data="d" :id="id"></mip-thing></div>',
+    });
+
+    var sample = {
+                     email: { type: 'email', value: 'darren@cauthon.com' },
+                     first_name: { type: 'text', value: 'Darren' },
+                     description: { type: 'textarea', value: 'more data' },
+                     size: { type: 'select', value: 'medium', options: ['small', 'medium', 'large']},
+                     heynow: { type: 'keyvalue',
+                             value: {
+                                 first_name: 'John',
+                                 last_name: 'Doe',
+                             },
+                             editors: [
+                                         { id: 'new_key', target: 'key', field: { type: 'text', value: '', default: '' } },
+                                         { id: 'new_value', target: 'value', field: { type: 'text', value: '', default: '' } }
+                                      ] },
+                     past: { type: 'editgrid',
+                             value: [
+                                 { name: 'Godzilla', quantity: 1 },
+                                 { name: 'Mothra', quantity: 2 },
+                             ],
+                             editors: [
+                                         { id: 'new_name', target: 'name', field: { type: 'text', value: '', default: '' } },
+                                         { id: 'new_quantity', target: 'quantity', field: { type: 'select', value: '1', options: [1, 2, 3], default: 1 } }
+                                      ] },
+                     super_action: { type: 'button', click: function(x) { console.log(x) } },
+                 };
+
+    var app = null;
+
+    axios.get('/fluxs')
+         .then(function(data){
+
+             var configs = {};
+             data.data.fluxs.map(function(x){
+                 configs[x.name] = x.config;
+             });
+
+             var setup = {
+                   event: { type: 'json', value: '{}' },
+                   id: { type: 'text', value: '' },
+                   name: { type: 'text', value: '' },
+                   flux: { type: 'select', value: data.data.fluxs[0].name, options: data.data.fluxs.map(function(x){ return x.name })},
+             };
+
+             for (var key in configs)
+             {
+                 configs[key].go = { type: 'button', click: function(c) {
+                                      app.results = [];
+                                      Vue.set(app.results, 'loading', true);
+                                      axios.post('/run', { config: c, setup: thingToData(app.setup) })
+                                       .then(function(r){
+                                           Vue.set(app.results, 'loading', false);
+                                           for (var key in r.data.result)
+                                               app.results.push({darren: { type:'jsonview', value: r.data.result[key], view: 'thin' }});
+                                        });
+                                     } };
+
+                 configs[key].save = { type: 'button', click: function(config) {
+                     var setup = thingToData(app.setup);
+                                       var flux = {
+                                           id: setup.id,
+                                           name: setup.name,
+                                           config: config,
+                                       };
+                     app.flow.fluxs.push(flux);
+                     console.log(flux);
+                                     }
+                 };
+             }
+
+             app = new Vue({
+                 el: '#app',
+                 data: {
+                     flow: {
+                         fluxs: [],
+                     },
+                     configs: configs,
+                     setup: setup,
+                     results: [],
+                 }
+            });
+    });
+</script>