simbiotes 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: defab4e9159fb7dbe9068fcdc94d83d348983bbe
+  data.tar.gz: bfc041d76870d672a67997de703ac7a86462365b
+SHA512:
+  metadata.gz: 9b6076785ffd4471c6d7e30b0dee448297e818911a645269e3d7b4bb816450f914954813b7c7b1769947e954b4face9a5c7d3582736a00d032a0cfe593c73c5c
+  data.tar.gz: 14e72ba3bf7d6210bdee462038c8543a61a798587ef6acebb340c7c50e91b4215571bf3443edde7c41597b7fc2c6288fdf7dadb03ac31d21cd374b45f30a4146

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 MicroArx Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,194 @@
+# Simbiotes
+The easy way to make your Rails application interact with IoT devices.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "simbiotes", :git => "https://github.com/MicroArx/simbiotes-gem.git"
+```
+
+Or install it yourself as:
+```bash
+$ gem install simbiotes #Not working yet
+```
+
+And then execute:
+```bash
+$ bundle
+$ rails generate simbiotes:install
+```
+On the Simbiotes portal located at www.simbiotes.com, you can create a Hive for your project. Hives have Workers (each type of IoT device in your project will have a corresponding worker in the Hive).  Workers have Drivers and, optionally, Scripts.  Drivers and Scripts have interfaces.  An example worker might be a Thermostat.  The Thermostat has a Control Script with two interfaces: temperature and target temperature.  If you set the target temperature to 72 and the temperature is 65, the Thermostat will turn the heat on.  We'll use this example again and flesh it out below.
+
+Once you have created a Hive, it will give you a public and a private API key.  Best practice is to set environment variables in your development, test and production environments to equal these API keys.  Then, set config.public_key and config.private_key in config/initializers/simbiotes.rb to those environment variables.  You can enter the API keys directly into the configuration file, but you should only do this if you never plan to put your Rails application and Hive into production, as it is a significant security risk.
+
+
+```ruby
+Simbiotes.configure do |config|
+	config.public_key = ENV['SIMBIOTES_PUBLIC_API_KEY']
+	config.private_key = ENV['SIMBIOTES_PRIVATE_API_KEY']
+	config.local_port = 8001
+	config.server_port = 8000
+	config.local_logging = true
+end
+```
+
+## Usage
+After you have installed the API keys, log in to the Simbiotes portal (www.simbiotes.com) to see that your Hive has Workers and that those Workers have Drivers and, if applicable, Scripts defined.  Each Worker, Driver or Script will have one or more Interfaces.  For example, if you are making a connected Thermostat, your Hive might have a Worker named 'Thermostat' and it might have the following Drivers/Scripts: Thermometer, Furnace and Control.
+
+Each of the Drivers/Scripts has Interfaces (all of this would be viewable on the www.simbiotes.com portal).  The Control script might have two interfaces: Temperature and Target Temperature.
+
+We want to be able to interact with these interfaces easily through our Rails application for all of the Thermostats that we have out there in the field.
+
+### Models and Tables
+
+To do this, we will create a model in our Rails application with attributes that correspond to the interfaces we want to interact with.  We will then create records in our Rails database that correspond to our devices.  Once we've done that, we can interact with a database record using ActiveRecord as usual, but the attribute values from our database records will be automatically synced to the corresponding device.
+
+Because our model is going to sync with our IoT devices, we need to use the Simbiotes model generator that comes with the gem to create the model rather than the model generator that comes by default with Rails.  To use it, we pass two arguments, the name of the Worker and the name of the Driver or Script that we want to interact with.  In this case, our worker is Thermostat and we want to interact with Control, so we create the model as follows:
+
+```bash
+$ rails generate simbiotes:model Thermostat Control
+```
+
+This generator actually creates a model and a module.  The module is in app/models/thermostat.rb and the model in app/models/thermostat/control.rb.  If you create models that correspond to one or more of your Thermostat's other Drivers/Scripts, they will be placed in the app/models/thermostat directory as well.
+
+Now you should migrate your database in order to create the database tables that correspond to your model.
+
+```bash
+$ rake db:migrate
+```
+
+The migration creates three tables: thermostat_controls, thermostat_control_temperature_logs and thermostat_control_target_temperature_logs.  The thermostat_controls table holds the data for temperature and target temperature for all of the devices within your Hive.  
+
+### Instances and Devices
+
+Now that you have your models and database tables created, you can use them to communicate with the devices that are out in the field.
+
+The first thing to do is to create database records that correspond to actual devices.  On the Simbiotes Portal (www.simbiotes.com) you will see a list of Worker Instances (each Instance represents an individual device of that particular Worker type) on each Worker page.  Each Worker Instance has an id, you'll see them as a long string of characters on the page, one for each Worker Instance.
+
+Now, run:
+
+```bash
+$ rails console
+```
+
+This will open up an irb console with your Rails environment (including the Simbiotes gem) loaded.
+
+In your console run:
+
+```irb
+> Thermostat.sync_device_instances
+```
+
+That will create a database record for each device you currently have.
+
+Next, exit your rails console by typing:
+
+```irb
+> exit
+```
+
+The next thing we need to do is establish a communications channel we can use to communicate between our Rails application and the devices in the field.  To do this, we use a local server that handles sending communications to the remote devices and handles communications that we will receive from them.
+
+To start it up type:
+
+```bash
+$ rake comms:start
+```
+
+This starts our communications server.  If you want to stop the communications server for any reason simply type:
+
+```bash
+$ rake comms:stop
+```
+
+Note that you can only communication with devices if the local communications server is running.
+
+### Creating and uploading scripts.
+
+As mentioned, Workers can have both Drivers and Scripts.  These are quite similar, but have a very important difference.  Drivers are reasonably direct representations of physical interfaces that the device has.  In the case of the Thermostat, it has two Drivers, a Thermometer Driver and a Furnace Driver.  
+
+The Thermometer Driver has one read-only Interface: Temperature.  This Interface corresponds with the actual physical temperature sensor on the device that allows us to know what the ambient temperature is at the device.
+
+The Furnace Driver has one read/write Interface: Heat.  This Interface turns the furnace on or off, and corresponds to the physical interface that the Thermostat has with the physical furnace.
+
+In addition to these low level drivers, what we want is something that lets us interact with them and run some logic on board the device.  This is where the Script comes in.  Like Drivers, Scripts have Interfaces that we can interact with via simple Rails ActiveRecord database operations.  The difference is that Scripts calculate the values that their Interfaces hold based on logic and inputs from Drivers or other Scripts on the Device.
+
+In the Thermostat case, what we want is to be able to set a target temperature (as mentioned above).  If the ambient temperature is below the target temperature, we want to turn on the heat.  If the ambient temperature is above the target temperature, we want to turn the heat off.
+
+We could do this using logic in our Rails application, instantiate the Thermometer and Furnace Drivers, and set the heat on or off as required.  But it would be better to run this logic on the device, and have our Rails application send target temperatures to the device.
+
+When you created the Thermostat::Control model, you also created a stub Script file that can contain the logic that will run on the device.  this file is at lib/scripts/simbiotes/thermostat/control.rb
+
+We edit the stub script file to look like the following:
+
+```ruby
+#######
+# This script will be deployed to your device.
+# The $global variables below represent the values your script will receive/needs to provide to/from its various interfaces and inputs.
+# Your script should change the value of these variables to what they should be, and they will then get passed back.
+# You can also add additional global variables.  If you do, these will be passed back to the script along with the 
+# interface and input variables the next time the script is invoked.  These are useful for keeping state across script 
+# invocations.
+
+  $Temperature
+  $Target_Temperature
+  $Thermometer_Temperature
+  $Furnace_Heat
+  
+  if $Thermometer_Temperature < $Target_Temperature
+    $Furnace_Heat = "on"
+  else
+    $Furnace_Heat = "off"
+  end
+  
+  $Temperature = $Thermometer_Temperature
+```
+
+The $Temperature and $Target_Temperature variables hold the values for the Script's interfaces.  The script also has two inputs (defined on the Simbiotes portal: www.simbiotes.com).  These are the Thermometer Driver's temperature interface and the Furnace Driver's Heat interface.  The $Thermometer_Temperature and $Furnace_Heat variables hold the values of these interfaces, respectively.
+
+The script has the logic to turn the heat on or off depending on the temperature's relationship to the target temperature.  The last line of the script sets the $Temperature variable equal to the $Thermometer_Temperature so that we can access the correct temperature using the temperature interface of the Control script, and not need to access the interface of the Thermometer driver in Rails at all.
+
+Once we have completed our edits to the script, we publish it to the Hive by running the following command:
+
+```bash
+$ rake script:publish[Thermostat:Control]
+```
+
+### Communicating with Devices
+
+Now that the preliminaries are out of the way, let's communicate with devices.
+
+Open up your rails console again by typing:
+
+```bash
+$ rails c
+```
+
+In your console, type the following to get a device instance and assign it to the variable d:
+
+```irb
+> d = Thermostat::Control.first
+```
+
+The first thing to do is to synchronize the database's data with the data from the device. (This sends a get request for each Interface in the current Driver/Script)  To do this type in your console:
+
+```irb
+> d.sync
+```
+
+Now that you are synced with the device, you can set the device's Interfaces easily right from Rails.  Let's say you want to set the temperature of your thermostat to 68 degrees.  Here's how you do it:
+
+```irb
+> d.target_temperature = 68
+> d.save
+```
+
+All of the communications to the device are taken care of for you.  If the value of these Interfaces changes (if the ambient temperature rises or falls for example) then your database will be kept up to date via the communications server without needing to sync the device instance going forward.
+
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,33 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Simbiotes'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/generators/simbiotes/create_model/USAGE

@@ -0,0 +1,8 @@
+Description:
+    This generator creates model files with the right code for Simbiotes interactions.
+
+Example:
+    rails generate simbiotes:model Thing
+
+    This will create:
+        app/models/thing.rb

data/lib/generators/simbiotes/create_model/create_model_generator.rb

@@ -0,0 +1,50 @@
+module Simbiotes
+  class CreateModelGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+    argument :parent, :type => :string
+    argument :name, :type => :string
+    argument :portal, :type => :string, :required => false
+  
+    def copy_model_file
+      if portal == "true"
+        @c = Simbiotes.get_attributes(parent, name)
+      end
+      template "simbiotes_module.rb.erb", "app/models/#{module_file_name}.rb"
+      template "simbiotes_model.rb.erb", "app/models/#{module_file_name}/#{file_name}.rb"
+      unless Simbiotes.configuration.local_logging == false
+        if portal == "true"
+          @c[:attributes].each do |k,v|
+            @k = k
+            @v = v
+            template "simbiotes_logs_model.rb.erb", "app/models/#{module_file_name}/#{file_name}_#{@k.underscore.downcase.gsub(" ","_")}_log.rb"
+          end
+        else
+          @k = name
+          template "simbiotes_logs_model.rb.erb", "app/models/#{module_file_name}/#{file_name}_#{@k.underscore.downcase.gsub(" ","_")}_log.rb"
+        end
+      end
+    end
+    
+    private
+    
+    def file_name
+      name.underscore
+    end
+    
+    def module_file_name
+      parent.underscore
+    end
+    
+    def class_name
+      name.classify
+    end
+    
+    def module_name
+      parent.classify
+    end
+    
+    def table_prefix
+      parent.underscore + "_"
+    end
+  end
+end

data/lib/generators/simbiotes/create_model/templates/simbiotes_logs_model.rb.erb

@@ -0,0 +1,7 @@
+module <%= module_name %>
+  class <%= class_name + @k.gsub(" ","_").classify%>Log < ApplicationRecord
+  
+  belongs_to :<%=class_name.downcase %>
+  
+  end
+end

data/lib/generators/simbiotes/create_model/templates/simbiotes_model.rb.erb

@@ -0,0 +1,27 @@
+module <%= module_name %>
+  class <%= class_name %> < ApplicationRecord
+    <% unless @c == nil %># The methods that correspond to device interfaces are <% @c[:attributes].each do |k,v| %><%=k.downcase.gsub(" ", "_")%> <% end %><% end %>
+    <%unless @c == nil %><% unless Simbiotes.configuration.local_logging == false %><% @c[:attributes].each do |k,v| %>
+    has_many :<%= class_name.underscore.downcase.gsub(" ", "_") + "_#{k.underscore.downcase.gsub(" ", "_")}_logs"%>, dependent: :destroy
+    <% end %><% end %><% end %>
+    attr_accessor :skip_extract
+    after_commit :extract, unless: :skip_extract
+    <% unless @c == nil %><% @c[:attributes].each do |k,v| %><% unless v[:values] == "" %>validates :<%= k.downcase.gsub(" ", "_").underscore %>, inclusion: { in: %w(<%= v[:values].join(" ") %>,
+    message: "%{value} is not a valid <%= k %>" }<% end %><% unless v[:range] == "" %>
+    validates :<%= k.gsub(" ", "_").underscore %>, inclusion: { in: <%= v[:range] %>,
+    message: "%{value} is not within the range <%= v[:range] %>" }<% end %><% if v[:type] == "enum" %>
+    enum <%= k.gsub(" ", "_").underscore %>: <%= v[:values] %><% end %><% end %><% end %>
+  
+    
+    def sync
+      Simbiotes.sync(self)
+    end
+    
+    private
+  
+    def extract
+      Simbiotes::Extract.send(self)
+    end
+  
+  end
+end

data/lib/generators/simbiotes/create_model/templates/simbiotes_module.rb.erb

@@ -0,0 +1,10 @@
+module <%= module_name %>
+  def self.table_name_prefix
+    '<%= table_prefix %>'
+  end
+  
+  def self.sync_device_instances
+    Simbiotes.sync_device_instances(self.name)
+  end
+  
+end

data/lib/generators/simbiotes/create_table/USAGE

@@ -0,0 +1,9 @@
+Description:
+    Creates a database table with attributes that Simbiotes requires. 
+
+Example:
+    rails generate simbiotes:create_table Table attribute:type attribute:type ... attribute:type
+
+    This will create:
+        db/migrate/{datetime_stamp}_create_table.rb
+				db/migrate/{datetime_stamp}_create_table_logs.rb

data/lib/generators/simbiotes/create_table/create_table_generator.rb

@@ -0,0 +1,52 @@
+module Simbiotes
+  class CreateTableGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+    argument :parent, :type => :string
+    argument :name, :type => :string
+    argument :attributes, :type => :hash, :required => false
+    
+    def copy_create_table_files
+      template "create_table.rb.erb", "db/migrate/#{date_string}_create_#{plural_name}.rb"
+      unless Simbiotes.configuration.local_logging == false
+        sleep 1
+        attributes.each do |k,v|
+          @k = k
+          @v = v
+          template "create_logs_table.rb.erb", "db/migrate/#{date_string}_create_#{table_name}_#{@k}_logs.rb"
+          sleep 1
+        end
+      end
+    end
+    
+    private
+    
+    def date_string
+      date_string = DateTime.now.strftime("%Y%m%d%H%M%S")
+    end
+    
+    def plural_name
+      parent.underscore + "_" + name.underscore.pluralize
+    end
+    
+    def table_name
+      parent.underscore + "_" + name.underscore
+    end
+    
+    def class_name
+      name.classify
+    end
+    
+    def plural_class_name
+      parent.classify + name.classify.pluralize
+    end
+    
+    def logs_class_name(k)
+      parent.classify + name.classify + k.classify + "Logs"
+    end
+    
+    def logs_table_name(k)
+      parent.underscore + "_" + name.underscore + "_" + k.underscore + "_" + "logs"
+    end
+    
+  end
+end

data/lib/generators/simbiotes/create_table/templates/create_logs_table.rb.erb

@@ -0,0 +1,14 @@
+class Create<%= logs_class_name(@k) %> < ActiveRecord::Migration[5.1]
+  def change
+    create_table :<%= logs_table_name(@k) %> do |t|
+      t.<%= @v %> :<%= @k %>
+      t.boolean :<%= @k %>_ack
+      t.boolean :<%= @k %>_complete
+      t.string :<%= @k %>_timestamp
+      t.string :<%= @k %>_status
+      t.string :<%= @k %>_action
+      t.integer :<%= name.downcase %>_id
+      t.timestamps
+    end
+  end
+end

data/lib/generators/simbiotes/create_table/templates/create_table.rb.erb

@@ -0,0 +1,16 @@
+class Create<%= plural_class_name %> < ActiveRecord::Migration[5.1]
+  def change
+    create_table :<%= plural_name %> do |t|
+      <% attributes.each do |k,v| %>
+      t.<%= v %> :<%= k %>
+      t.boolean :<%= k %>_ack
+      t.boolean :<%= k %>_complete
+      t.string :<%= k %>_timestamp
+      t.string :<%= k %>_status
+      t.string :<%= k %>_action
+      <% end %>
+      t.string :simbiotes_instance
+      t.timestamps
+    end
+  end
+end

data/lib/generators/simbiotes/initializer/USAGE

@@ -0,0 +1,8 @@
+Description:
+    This generator creates an simbiotes.rb initializer file at config/initializers
+
+Example:
+    rails generate simbiotes_initializer
+
+    This will create:
+        config/initializers/simbiotes.rb

data/lib/generators/simbiotes/initializer/initializer_generator.rb

@@ -0,0 +1,18 @@
+module Simbiotes
+  class InitializerGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+    argument :portal, :type => :string, :required => false
+    
+    def copy_initializer_file
+      if portal == "true"
+        @c = Simbiotes::Portal.parse_all_interfaces
+        template "simbiotes_targets.rb.erb", "config/initializers/simbiotes_targets.rb"
+      else
+        template "simbiotes.rb.erb", "config/initializers/simbiotes.rb"
+      end
+    end
+    
+    
+    
+  end
+end

data/lib/generators/simbiotes/initializer/templates/simbiotes.rb.erb

@@ -0,0 +1,7 @@
+Simbiotes.configure do |config|
+  config.public_key = nil #set this to an Environment variable
+  config.private_key = nil #set this to an Environment variable
+  config.local_port = 8001
+  config.server_port = 8000
+  config.local_logging = true
+end

data/lib/generators/simbiotes/initializer/templates/simbiotes_targets.rb.erb

@@ -0,0 +1,3 @@
+Simbiotes.configure do |config|
+  config.targets = <%= @c %>
+end

data/lib/generators/simbiotes/install/USAGE

@@ -0,0 +1,11 @@
+Description:
+    Install the initial files for the Simbiotes gem.
+
+Example:
+    rails g simbiotes:install
+
+    This will create:
+        config/initializers/simbiotes.rb
+				lib/scripts/server.rb
+				lib/scripts/server_control.rb
+				lib/tasks/comm_server.rake

data/lib/generators/simbiotes/install/install_generator.rb

@@ -0,0 +1,11 @@
+module Simbiotes
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+  
+    def install
+      generate "simbiotes:initializer"
+      generate "simbiotes:script"
+    end
+    
+  end
+end

data/lib/generators/simbiotes/migration/USAGE

@@ -0,0 +1,10 @@
+Description:
+    Creates database migrations for Simbiotes tables
+
+Example:
+    rails generate simbiotes:migration AddAttributeToTableName attribute:type attribute:type ... attribute:type
+
+    This will create:
+        db/migrate/{datetime_string}_migration_name.rb
+
+		The AddAttributeToTableName argument is flexible, but expects an existing Simbiotes table name after the "To" portion of the name.

data/lib/generators/simbiotes/migration/migration_generator.rb

@@ -0,0 +1,54 @@
+module Simbiotes
+  class MigrationGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+    argument :name, :type => :string
+    argument :attributes, :type => :hash, :required => true
+  
+    def copy_create_table_files
+      template "migrate_table.rb.erb", "db/migrate/#{date_string}_#{underscore_name}.rb"
+      sleep 1
+      attributes.each do |k,v|
+        @k = k
+        @v = v
+        template "create_logs_table.rb.erb", "db/migrate/#{date_string}_#{underscore_name}_logs.rb"
+        sleep 1
+      end
+    end
+    
+    private
+    
+    def date_string
+      date_string = DateTime.now.strftime("%Y%m%d%H%M%S")
+    end
+  
+    def table_name
+      array = name.underscore.split('_')
+      i = 0
+      new_array = Array.new
+      marker = false
+      while i < array.length
+        if marker == true
+          new_array << array[i]
+        end
+        if array[i] == "to"
+          marker = true
+        end
+        i += 1
+      end
+      new_array.join('_')
+    end
+  
+    def underscore_name
+      name.underscore
+    end
+  
+    def class_name
+      name.classify
+    end
+  
+    def logs_table_name(k)
+      table_name + "_" + k.underscore + "_" + "logs"
+    end
+  
+  end
+end

data/lib/generators/simbiotes/migration/templates/create_logs_table.rb.erb

@@ -0,0 +1,14 @@
+class <%= class_name %>Logs < ActiveRecord::Migration[5.1]
+  def change
+    create_table :<%= logs_table_name(@k) %> do |t|
+      t.<%= @v %> :<%= @k %>
+      t.boolean :<%= @k %>_ack
+      t.boolean :<%= @k %>_complete
+      t.string :<%= @k %>_timestamp
+      t.string :<%= @k %>_status
+      t.string :<%= @k %>_action
+      t.integer :<%= table_name %>_id
+      t.timestamps
+    end
+  end
+end

data/lib/generators/simbiotes/migration/templates/migrate_table.rb.erb

@@ -0,0 +1,12 @@
+class <%= class_name %> < ActiveRecord::Migration[5.1]
+  def change
+    <% attributes.each do |k,v| %>
+    add_column :<%= table_name %>, :<%= k %>, :<%= v %>
+    add_column :<%= table_name %>, :<%= k %>_ack, :boolean
+    add_column :<%= table_name %>, :<%= k %>_complete, :boolean
+    add_column :<%= table_name %>, :<%= k %>_timestamp, :string
+    add_column :<%= table_name %>, :<%= k %>_status, :string
+    add_column :<%= table_name %>, :<%= k %>_action, :string
+    <% end %>
+  end
+end

data/lib/generators/simbiotes/model/USAGE

@@ -0,0 +1,11 @@
+Description:
+    Creates a model and associated database table with the attributes specified.  If using data from the portal (recommended) Worker should be the name of a worker defined in your Hive, and Model should be the name of a Driver or Script in that Worker.
+
+Example:
+    rails generate simbiotes:model Worker Model attribute:type attribute:type ... attribute:type
+
+    This will create:
+				app/models/worker.rb
+				app/models/worker/model.rb
+        db/migrate/{datetime_stamp}_create_table.rb
+				db/migrate/{datetime_stamp}_create_table_attribute_logs.rb