mushy 0.7.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32162cc00416efb4669436924df21b3cc80d59c2ec11b243f0210125e3bcb6dc
-  data.tar.gz: 0e6e74b96b1988ad3c8792d0e42fdc1dd4a095247e7517429454692b152ddc23
+  metadata.gz: 85eb693e91e6a27ab2943d07ab5d4a7d3544c958793aac1830a3d03a81d98001
+  data.tar.gz: be51f8e5b94fb4184c1e8f7ba037de1a5ae9901a0fd7ace4fc85e6cc182a864b
 SHA512:
-  metadata.gz: 7c89eaf89944c50a8478a8e0b0419ea8cad1f283bb18eb55edd9f38b59ad8c282895f94bac14b697a2e003225ec61cc169642cd1c1f6eeff009084f04094b3d9
-  data.tar.gz: dcb83c01e8da06d5d896c646a839b4e8b764fc3bba4d7d6393998c2670b7bd7c54d6bf2feeb9999cd85993cdf3afaa8ab778ebe57e37a84ec5a718f0246f984c
+  metadata.gz: 8bc9319d1c55c581d91377c28ec526ec2215c66962eae0723cfa47eaca5599d6a5bebc439ce423864c37544e6b6250354235f14dddb182c370836c9a289ddd66
+  data.tar.gz: '08efdce27c2820c503ef940224c9b27da0d4c88f11d3f837d50ca1ba99f062de019b1143dc4a3d5bf575b1789b9218c913315570ef00d82b7173c0cbbaa8299a'

data/lib/mushy.rb

@@ -3,9 +3,16 @@ require 'symbolized'
 
 Dir[File.dirname(__FILE__) + '/mushy/*.rb'].each { |f| require f }
 
-important_flux_files = ['bash', 'browser'].map { |x| "#{x}.rb" }
+important_flux_files = [
+                        'bash',
+                        'browser',
+                        'simple_python_program',
+                       ].map { |x| "#{x}.rb" }
+
 Dir[File.dirname(__FILE__) + '/mushy/fluxs/*.rb']
-  .sort_by { |f| important_flux_files.any? { |x| f.end_with?(x) } ? 0 : 1 }
-  .each { |f| require f }
+  .map     { |x| [x, important_flux_files.find_index(x.split("\/")[-1]) || 9999999] }
+  .sort_by { |x| x[1] }
+  .map     { |x| x[0] }
+  .each    { |f| require f }
 
 Dir[File.dirname(__FILE__) + '/mushy/builder/*.rb'].each { |f| require f }

data/lib/mushy/flow.rb

@@ -17,15 +17,28 @@ module Mushy
         .flatten
     end
 
+    def adjust_data data
+      fluxs
+        .select { |x| x.respond_to? :adjust_data }
+        .reduce(data) { |t, i| i.adjust_data t }
+    end
+
     def self.build_flux record
       type = record[:type] || record['type'] || record[:flux] || record['flux'] || 'Flux'
       flux = Object.const_get("Mushy::#{type}").new
       flux.id = record[:id] || record['id'] || flux.id
       flux.type = type
       flux.config = SymbolizedHash.new(record[:config] || record['config'])
+      flux.flow = Mushy::Flow.new
       flux
     end
 
+    def build_flux record
+      Mushy::Flow.build_flux(record).tap do |flux|
+        flux.flow = self
+      end
+    end
+
     def self.parse data
       data = JSON.parse data
 
@@ -34,7 +47,7 @@ module Mushy
 
       flow = new
 
-      flow.fluxs = data_fluxs.map { |s| build_flux s }
+      flow.fluxs = data_fluxs.map { |s| flow.build_flux s }
 
       fluxs_with_parent_ids = flow.fluxs.reduce({}) { |t, i| t[i.id] = []; t }
       data_fluxs.map { |r| fluxs_with_parent_ids[r['id']] = r['parents'] || [] }

data/lib/mushy/flux.rb

@@ -8,6 +8,7 @@ module Mushy
     attr_accessor :subscribed_to
     attr_accessor :config
     attr_accessor :masher
+    attr_accessor :flow
 
     def initialize
       guard
@@ -39,20 +40,18 @@ module Mushy
 
       incoming_event = SymbolizedHash.new(incoming_event) if incoming_event.is_a?(Hash)
 
-      event = incoming_event
-
-      incoming_split = masher.mash(config, event)[:incoming_split]
+      incoming_split = masher.mash(config, incoming_event)[:incoming_split]
       config_considering_an_imcoming_split = config
                                                .reject { |x, _| incoming_split && x.to_s == 'join' }
                                                .reduce({}) { |t, i| t[i[0]] = i[1]; t }
 
-      events = incoming_split ? incoming_event[incoming_split] : [event]
+      events = incoming_split ? incoming_event[incoming_split] : [incoming_event]
 
       results = events.map { |e| execute_single_event e, config_considering_an_imcoming_split }
 
       return results.first unless incoming_split
 
-      results = join_these_results([results].flatten, event, config[:join]) if config[:join]
+      results = join_these_results([results].flatten, incoming_event, config[:join]) if config[:join]
 
       results.flatten
     end

data/lib/mushy/fluxs/collection.rb

@@ -2,8 +2,6 @@ module Mushy
 
   class Collection < Flux
 
-    attr_accessor :collection
-
     def self.details
       {
         name: 'Collection',
@@ -11,9 +9,14 @@ module Mushy
         config: {
           id: {
                 description: 'The path to the unique id in the body of the element.',
-                type: 'id',
-                value: { url: 'a|@href' },
+                type: 'text',
+                value: '{{id}}',
               },
+          collection_name: {
+                             description: 'The name of the collection to interact with.',
+                             type:        'text',
+                             value:       'records',
+                           },
           operation: {
                        description: 'Perform this operation.',
                        type:        'select',
@@ -24,31 +27,26 @@ module Mushy
       }
     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]]
+      config[:id]
     end
 
     def all event, config
-      self.collection.values
+      the_collection(config).values
     end
 
     def delete event, config
-      self.collection.delete get_the_id(event, config)
+      the_collection(config).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)]
+      if the_collection(config)[get_the_id(event, config)]
         update event, config
       else
         insert event, config
@@ -56,18 +54,38 @@ module Mushy
     end
 
     def update event, config
-      item = self.collection[get_the_id(event, config)]
+      item = the_collection(config)[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
+      the_collection(config)[get_the_id(event, config)] = event
       event[config[:operation_performed]] = 'inserted' if config[:operation_performed]
       event
     end
 
+    def the_collection config
+      Mushy::Collection.guard_the_flow self.flow
+      the_collection_name = config[:collection_name]
+
+      get_the_collection the_collection_name
+    end
+
+    def get_the_collection name
+      found_collection = self.flow.collection_data[name]
+      return found_collection if found_collection
+      self.flow.collection_data[name] = SymbolizedHash.new
+    end
+
+    def self.guard_the_flow flow
+      return if flow.respond_to?(:collection_data)
+
+      flow.instance_eval { class << self; self end }.send(:attr_accessor, :collection_data)
+      flow.collection_data = {}
+    end
+
   end
 
 end

data/lib/mushy/fluxs/global_variables.rb

@@ -0,0 +1,39 @@
+module Mushy
+  
+  class GlobalVariables < Flux
+
+    attr_accessor :state
+
+    def self.details
+      {
+        name: 'GlobalVariables',
+        description: 'Add global variables.',
+        config: {
+          values: {
+                    description: 'Provide key/value pairs that will be set as global variables.',
+                    label:       'Variables',
+                    type:        'keyvalue',
+                    value:       {},
+                  },
+        },
+      }
+    end
+
+    def initialize
+      super
+      self.state = SymbolizedHash.new
+    end
+
+    def adjust_data data
+      state.merge data
+    end
+
+    def process event, config
+      values = config[:values] || SymbolizedHash.new
+      state.merge! values
+      event
+    end
+
+  end
+
+end

data/lib/mushy/fluxs/pdf.rb

@@ -4,8 +4,8 @@ module Mushy
 
     def self.details
       details = Browser.details
-      details['name'] = 'Pdf'
-      details['description'] = 'Turn a URL into a PDF.'
+      details[:name] = 'Pdf'
+      details[:description] = 'Turn a URL into a PDF.'
 
       details[:config][:path] = {
          description: 'The path of the PDF file to save.',

data/lib/mushy/fluxs/read_json.rb

@@ -0,0 +1,28 @@
+require 'csv'
+
+module Mushy
+  
+  class ReadJson < Flux
+
+    def self.details
+      {
+        name: 'ReadJson',
+        description: 'Read JSON and output it as an event.',
+        config: {
+          json: {
+                  description: 'The JSON contents that will be returned as an event.',
+                  type:        'text',
+                  value:       'json',
+                },
+        },
+      }
+    end
+
+    def process event, config
+      return nil unless config[:json].to_s != ''
+      JSON.parse config[:json]
+    end
+
+  end
+
+end

data/lib/mushy/fluxs/screenshot.rb

@@ -4,8 +4,8 @@ module Mushy
 
     def self.details
       details = Browser.details
-      details['name'] = 'Screenshot'
-      details['description'] = 'Take a screenshot of the browser.'
+      details[:name] = 'Screenshot'
+      details[:description] = 'Take a screenshot of the browser.'
 
       details[:config].merge!(Mushy::WriteFile.file_saving_config.tap do |x|
         x[x.keys.first][:value] = 'file.jpg'

data/lib/mushy/fluxs/sense_hat_environmental_sensors.rb

@@ -0,0 +1,56 @@
+module Mushy
+
+  class SenseHatEnvironmentalSensors < SimplePythonProgram
+
+    def self.details
+      {
+        name: 'SenseHatEnvironmentalSensors',
+        description: 'Pull values from the Sense HAT environmental sensors.',
+        config: Mushy::SimplePythonProgram.default_config,
+      }.tap do |c|
+        measurements
+          .sort_by { |x| default_measurements.include?(x) ? 0 : 1 }
+          .each do |measurement|
+            c[:config][measurement] = {
+                                        description: "Pull #{measurement}.",
+                                        type:        'boolean',
+                                        shrink:      true,
+                                        value:       default_measurements.include?(measurement) ? 'true' : '',
+                                      }
+        end
+      end
+    end
+
+    def self.measurements
+      [
+        :humidity,
+        :temperature,
+        :temperature_from_humidity,
+        :temperature_from_pressure,
+        :pressure,
+      ]
+    end
+
+    def self.default_measurements
+      [:humidity, :temperature, :pressure]
+    end
+
+    def python_program event, config
+      values = self.class.measurements
+                   .select { |x| config[x] == 'true' }
+                   .reduce({}) { |t, i| t[i] = "get_#{i}"; t}
+                   .map { |m| "\"#{m[0]}\": sense.#{m[1]}()" }
+                   .join(',')
+
+      <<PYTHON
+from sense_hat import SenseHat
+import json
+sense = SenseHat()
+value = json.dumps({#{values}})
+print(value)
+PYTHON
+    end
+
+  end
+
+end

data/lib/mushy/fluxs/sense_hat_led_matrix.rb

@@ -0,0 +1,283 @@
+module Mushy
+
+  class SenseHatLedMatrix < SimplePythonProgram
+
+    def self.details
+      {
+        name: 'SenseHatLedMatrix',
+        description: 'Interface with the LED Matrix.',
+        config: Mushy::SimplePythonProgram.default_config.tap do |config|
+          config[:get_pixels] = {
+                                  description: 'Specify the pixels you want returned as events. Use "all" to return all 64, 3,3 to return x:3 y:3, or "none" to return none.',
+                                  type:        'text',
+                                  shrink:      true,
+                                  value:       'all',
+                                }
+          config[:set_pixel] = {
+                                 description: 'Set a single pixel to the RGB color.',
+                                 type:        'text',
+                                 shrink:      true,
+                                 value:       '',
+                               }
+          config[:set_pixels] = {
+                                  description: 'An array of multiple pixels to set. The records must have coordinates and rgb values, just like what comes out of the get pixels call.',
+                                  type:        'text',
+                                  shrink:      true,
+                                  value:       '',
+                                }
+          config[:rgb] = {
+                            description: 'The RGB value as a comma-delimited list. Leave blank to not set a color.',
+                            type:        'text',
+                            shrink:      true,
+                            value:       '',
+                         }
+          config[:background_color] = {
+                                        description: 'The RGB of the background, which is used in some API calls.',
+                                        type:        'text',
+                                        shrink:      true,
+                                        value:       '',
+                                      }
+          config[:clear] = {
+                             description: 'The RGB color to apply to the entire grid.',
+                             type:        'text',
+                             shrink:      true,
+                             value:       '',
+                           }
+          config[:show_letter] = {
+                                   description: 'Show a single letter on the grid. Uses Rgb and Background Color.',
+                                   type:        'text',
+                                   shrink:      true,
+                                   value:       '',
+                                 }
+          config[:show_message] = {
+                                    description: 'Scroll a message across the grid. Uses Rgb and Background Color.',
+                                    type:        'text',
+                                    shrink:      true,
+                                    value:       '',
+                                  }
+          config[:load_image] = {
+                                  description: 'Load a 8x8 image.',
+                                  type:        'text',
+                                  shrink:      true,
+                                  value:       '',
+                                }
+          config[:set_rotation] = {
+                                    description: 'Rotate the image by these degrees.',
+                                    type:        'select',
+                                    options:     ['', '0', '90', '180', '270'],
+                                    shrink:      true,
+                                    value:       '',
+                                  }
+          config[:redraw] = {
+                              description: 'Redraw.',
+                              type:        'boolean',
+                              shrink:      true,
+                              value:       '',
+                            }
+          config[:low_light] = {
+                              description: 'Use the low light to turn down the brightness.',
+                              type:        'boolean',
+                              shrink:      true,
+                              value:       '',
+                            }
+          config[:flip_h] = {
+                              description: 'Flips the image horizontally.',
+                              type:        'boolean',
+                              shrink:      true,
+                              value:       '',
+                            }
+          config[:flip_v] = {
+                              description: 'Flips the image vertically.',
+                              type:        'boolean',
+                              shrink:      true,
+                              value:       '',
+                            }
+          config[:target] = {
+                              description: 'The target of these commands. "hat" is a SenseHAT plugged into your Raspberry Pi, and "emu" is the SenseHAT emulator. Defaults to "hat".',
+                              type:        'select',
+                              options:     ['', 'hat' , 'emu'],
+                              shrink:      true,
+                              value:       '',
+                            }
+        end
+      }
+    end
+
+    def python_program event, config
+
+      commands = [
+        :set_pixel_code_from,
+        :set_pixels_code_from,
+        :clear_pixels_code_from,
+        :show_letters_code_from,
+        :show_message_code_from,
+        :load_images_code_from,
+        :set_rotation_code_from,
+        :low_light_code_from,
+        :flip_h_code_from,
+        :flip_v_code_from,
+      ].map { |x| self.send x, event, config }
+       .select { |x| x.to_s != '' }
+       .join("\n")
+
+      hat = config[:target] == 'emu' ? 'sense_emu' : 'sense_hat'
+
+      <<PYTHON
+from #{hat} import SenseHat
+import json
+sense = SenseHat()
+#{commands}
+value = json.dumps({"all": #{get_pixels_code_from(event, config)}})
+print(value)
+PYTHON
+    end
+
+    def adjust data, event, config
+      limit = 8
+
+      coordinates = coordinates_from config[:get_pixels]
+
+      records = coordinates ? [data[:all]] : data[:all]
+
+      results = records.each_with_index.map do |item, index|
+        {
+          x: index % limit,
+          y: index / limit,
+          r: item[0],
+          g: item[1],
+          b: item[2],
+        }
+      end
+
+      if coordinates
+        results[0][:x] = coordinates[:x]
+        results[0][:y] = coordinates[:y]
+      end
+
+      results.each do |record|
+        record[:coordinate] = "#{record[:x]},#{record[:y]}"
+        record[:rgb] = "#{record[:r]},#{record[:g]},#{record[:b]}"
+      end
+
+      results
+    end
+
+    def rgb_from config
+      color_split = config.to_s.split ','
+      return nil unless color_split.count == 3
+      return [:r, :g, :b].each_with_index
+                          .reduce({}) { |t, i| t[i[0]] = color_split[i[1]].to_s.to_i ; t}
+    end
+
+    def coordinates_from config
+      coordinate_split = config.to_s.split ','
+      return nil unless coordinate_split.count == 2
+      return [:x, :y].each_with_index
+                      .reduce({}) { |t, i| t[i[0]] = coordinate_split[i[1]].to_s.to_i ; t}
+    end
+
+    def set_pixel_code_from event, config
+      rgb = rgb_from config[:rgb]
+      set_pixel_coordinates = coordinates_from config[:set_pixel]
+      return '' unless rgb
+      return '' unless set_pixel_coordinates
+
+      turn_these_to_pixels([ {
+                               coordinate: "#{set_pixel_coordinates[:x]},#{set_pixel_coordinates[:y]}",
+                               rgb: "#{rgb[:r]},#{rgb[:g]},#{rgb[:b]}",
+                             } ])
+    end
+
+    def set_pixels_code_from event, config
+      return '' unless config[:set_pixels]
+      turn_these_to_pixels config[:set_pixels]
+    end
+
+    def turn_these_to_pixels values
+      options = [:coordinate, :rgb]
+      values.map do |pixel|
+        options.reduce({}) { |t, i| t[i] = pixel[i].split(',') ; t}
+      end.map do |pixel|
+        "sense.set_pixel(#{pixel[:coordinate][0]}, #{pixel[:coordinate][1]}, [#{pixel[:rgb][0]}, #{pixel[:rgb][1]}, #{pixel[:rgb][2]}])"
+      end.join("\n")
+    end
+
+    def clear_pixels_code_from event, config
+      clear = rgb_from config[:clear]
+      return '' unless clear
+      "sense.clear(#{clear[:r]}, #{clear[:g]}, #{clear[:b]})"
+    end
+
+    def show_letters_code_from event, config
+      return '' if config[:show_letter].to_s == ''
+
+      rgb = rgb_from config[:rgb]
+      background_color = rgb_from config[:background_color]
+
+      args = ["\"#{config[:show_letter]}\""]
+      args << "text_colour=[#{rgb[:r]}, #{rgb[:g]}, #{rgb[:b]}]" if rgb
+      args << "back_colour=[#{background_color[:r]}, #{background_color[:g]}, #{background_color[:b]}]" if background_color
+      "sense.show_letter(#{args.join(',')})"
+    end
+
+    def show_message_code_from event, config
+      return '' if config[:show_message].to_s == ''
+
+      rgb = rgb_from config[:rgb]
+      background_color = rgb_from config[:background_color]
+
+      args = ["\"#{config[:show_message]}\""]
+      args << "text_colour=[#{rgb[:r]}, #{rgb[:g]}, #{rgb[:b]}]" if rgb
+      args << "back_colour=[#{background_color[:r]}, #{background_color[:g]}, #{background_color[:b]}]" if background_color
+      "sense.show_message(#{args.join(',')})"
+    end
+
+    def load_images_code_from event, config
+      return '' if config[:load_image].to_s == ''
+
+      args = ["\"#{config[:load_image]}\""]
+      args << config[:redraw].to_s.capitalize if config[:redraw].to_s != ''
+      "sense.load_image(#{args.join(',')})"
+    end
+
+    def set_rotation_code_from event, config
+      return '' if config[:set_rotation].to_s == ''
+      args = ["#{config[:set_rotation]}"]
+      args << config[:redraw].to_s.capitalize if config[:redraw].to_s != ''
+      "sense.set_rotation(#{args.join(',')})"
+    end
+
+    def low_light_code_from event, config
+      return '' if config[:low_light].to_s == ''
+      "sense.low_light = #{config[:low_light].capitalize}"
+    end
+
+    def flip_h_code_from event, config
+      return '' unless config[:flip_h].to_s == 'true'
+      args = []
+      args << config[:redraw].to_s.capitalize if config[:redraw].to_s != ''
+      "sense.flip_h(#{args.join(',')})"
+    end
+
+    def flip_v_code_from event, config
+      return '' unless config[:flip_v].to_s == 'true'
+      args = []
+      args << config[:redraw].to_s.capitalize if config[:redraw].to_s != ''
+      "sense.flip_v(#{args.join(',')})"
+    end
+
+    def get_pixels_code_from event, config
+      get_pixel_coordinates = coordinates_from config[:get_pixels]
+
+      if get_pixel_coordinates
+        "sense.get_pixel(#{get_pixel_coordinates[:x]}, #{get_pixel_coordinates[:y]})"
+      elsif config[:get_pixels].to_s.downcase == 'all'
+        'sense.get_pixels()'
+      else
+        '[]'
+      end
+    end
+
+  end
+
+end

data/lib/mushy/fluxs/simple_python_program.rb

@@ -0,0 +1,36 @@
+module Mushy
+
+  class SimplePythonProgram < Bash
+
+    def self.default_config
+      Mushy::Bash.details[:config].tap do |config|
+        config.delete :command
+        config.delete :directory
+      end
+    end
+
+    def process event, config
+
+      lines = python_program(event, config)
+                .split('\n')
+                .map { |x| x.rstrip }
+                .select { |x| x && x != '' }
+                .map { |x| x.gsub('"', '\"') }
+
+      config[:command] = "python -c \"#{lines.join(';')}\""
+
+      result = super event, config
+
+      return nil unless result[:success]
+
+      adjust SymbolizedHash.new(JSON.parse(result[:text])), event, config
+
+    end
+
+    def adjust data, event, config
+      data
+    end
+
+  end
+
+end

data/lib/mushy/fluxs/write_json.rb

@@ -0,0 +1,29 @@
+require 'csv'
+
+module Mushy
+  
+  class WriteJson < Flux
+
+    def self.details
+      {
+        name: 'WriteJson',
+        description: 'Write the incoming event as JSON.',
+        config: {
+          key: {
+                description: 'The key of the outgoing field that will contain the JSON.',
+                type:        'text',
+                value:       'json',
+              },
+        },
+      }
+    end
+
+    def process event, config
+      {
+        config[:key] => event.to_json
+      }
+    end
+
+  end
+
+end

data/lib/mushy/masher.rb

@@ -45,7 +45,15 @@ module Mushy
       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)
+        if segment.include?('[') && segment.include?(']')
+          the_splits = segment.split('[')
+          segment = the_splits[0]
+          index = the_splits[1].sub(']', '')
+          data = data.is_a?(Hash) ? (data[segment] || data[segment.to_sym]) : (data ? data.send(segment.to_sym) : nil)
+          data = data[index.to_i]
+        else
+          data = data.is_a?(Hash) ? (data[segment] || data[segment.to_sym]) : (data ? data.send(segment.to_sym) : nil)
+        end
       end
 
       data

data/lib/mushy/runner.rb

@@ -12,7 +12,7 @@ module Mushy
       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
+      events = run_event_with_flux starting_event, flux, flow
 
       while events.any?
         events = events.map { |e| runner.run_event_in_flow e, flow }.flatten
@@ -23,12 +23,14 @@ module Mushy
 
     def run_event_in_flow event, flow
       flow.fluxs_for(event)
-        .map { |s| runner.run_event_with_flux event, s }
+        .map { |s| runner.run_event_with_flux event, s, flow }
         .flatten
     end
 
-    def run_event_with_flux event, flux
-      [flux.execute(event.data)]
+    def run_event_with_flux event, flux, flow
+      data = event.data
+      data = flow.adjust_data data
+      [flux.execute(data)]
         .flatten
         .reject { |x| x.nil? }
         .map { |x| x.is_a?(Hash) ? build_event(x, event.flow_id, event.run_id, flux.id) : x }

data/mushy.gemspec

@@ -4,7 +4,7 @@ require 'mushy/version'
 
 Gem::Specification.new do |s|
   s.name           = 'mushy'
-  s.version        = '0.7.0'
+  s.version        = '0.13.0'
   s.date           = '2020-11-23'
   s.summary        = 'Process streams of work using common modules.'
   s.description    = 'This tool assists in the creation and processing of workflows.'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mushy
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Darren Cauthon
@@ -194,6 +194,7 @@ files:
 - lib/mushy/fluxs/format.rb
 - lib/mushy/fluxs/get.rb
 - lib/mushy/fluxs/git_log.rb
+- lib/mushy/fluxs/global_variables.rb
 - lib/mushy/fluxs/interval.rb
 - lib/mushy/fluxs/ls.rb
 - lib/mushy/fluxs/parse_html.rb
@@ -202,10 +203,15 @@ files:
 - lib/mushy/fluxs/pwd.rb
 - lib/mushy/fluxs/read_csv.rb
 - lib/mushy/fluxs/read_file.rb
+- lib/mushy/fluxs/read_json.rb
 - lib/mushy/fluxs/screenshot.rb
+- lib/mushy/fluxs/sense_hat_environmental_sensors.rb
+- lib/mushy/fluxs/sense_hat_led_matrix.rb
+- lib/mushy/fluxs/simple_python_program.rb
 - lib/mushy/fluxs/smtp.rb
 - lib/mushy/fluxs/times.rb
 - lib/mushy/fluxs/write_file.rb
+- lib/mushy/fluxs/write_json.rb
 - lib/mushy/masher.rb
 - lib/mushy/run.rb
 - lib/mushy/runner.rb