daf 0.3.0

data/lib/daf/actions/sms_action.rb

@@ -0,0 +1,25 @@
+require 'daf/action'
+require 'twilio-ruby'
+
+module DAF
+  # An action that sends an sms using twilio based on parameters
+  class SMSAction < Action
+    attr_option :to, String, :required
+    attr_option :message, String, :required
+    attr_option :from, String, :required
+    attr_option :sid, String, :required
+    attr_option :token, String, :required
+
+    attr_output :message_id, String
+
+    def client
+      @client ||= Twilio::REST::Client.new(@sid, @token)
+    end
+
+    def invoke
+      @message_id = client.account.messages.create(body: @message,
+                                                   to: @to,
+                                                   from: @from)
+    end
+  end
+end

data/lib/daf/command.rb

@@ -0,0 +1,55 @@
+require 'thread'
+Dir[File.dirname(__FILE__) + '/monitors/*'].each { |file| require file }
+Dir[File.dirname(__FILE__) + '/actions/*'].each { |file| require file }
+
+module DAF
+  # Represents a pair of Action and Monitor objects
+  # when requested, will begin watching the Monitor
+  # and when it triggers will invoke the action by
+  # default Command continues monitoring forever
+  # though subclasses may override this behavior
+  class Command
+    # Create a new command object from a data source
+    # @param datasource [CommandDataSource] The data source to use to initialize
+    # command object
+    def initialize(datasource)
+      @datasource = datasource
+    end
+
+    # Begins executing the command by starting the monitor specified in
+    # the data source - will return immediately
+    def execute
+      @thread = Thread.new do
+        if Thread.current != Thread.main
+          loop do
+            @datasource.monitor.on_trigger do
+              @datasource.action.activate(@datasource.action_options)
+            end
+          end
+        end
+      end
+    end
+
+    def cancel
+      @thread.kill
+    end
+  end
+
+  # Exception generated during loading or execution of command
+  class CommandException < Exception
+  end
+
+  # Data source to initialize command with
+  class CommandDataSource
+    # Overridden by subclasses - returns options that should be passed to action
+    def action_options
+    end
+
+    # Overridden by subclasses - returns action that should be used by command
+    def action
+    end
+
+    def monitor
+    end
+  end
+end

data/lib/daf/configurable.rb

@@ -0,0 +1,145 @@
+module DAF
+  # Module used for configurable objects internally
+  # adds the has_option class method that creates an option
+  # for use on Monitor and Action subclasses - it exposes
+  # the options that are present, and required types, so that
+  # parsers and UI can view them if required
+  module Configurable
+    # Processes given parameter into the defined options previously declared
+    # includes validation for types and any custom validators delcared
+    #
+    # @param [Hash<String,Object>] Hash of option name/value pairs, values
+    # must conform to validation rules for options or exception will be raised
+    def process_options(options)
+      options.each do |key, value|
+        key = key.to_s
+        fail OptionException, "No Option #{key}" unless self.class.options[key]
+        opt = send("#{key}")
+        opt.value = value
+        fail OptionException, "Bad value for option #{key}" unless opt.valid?
+      end
+      validate_required_options
+    end
+
+    def validate_required_options
+      self.class.send('required_options').each do |name|
+        opt = send("#{name}")
+        fail OptionException,
+             "Required option #{name} missing or invalid" unless opt.valid?
+      end
+    end
+
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+    end
+
+    private :validate_required_options
+    protected :process_options
+
+    # Class methods used by configurable classes
+    module ClassMethods
+      def setup_options
+        class_variable_get('@@options')
+        class_variable_get('@@required_options')
+      rescue
+        class_variable_set('@@options', {})
+        class_variable_set('@@required_options', [])
+      end
+
+      def setup_option(name, type, required, verifier)
+        define_method("#{name}") do
+          instance_variable_set('@' + name,
+                                Option.new(name, type, verifier)) unless
+            instance_variable_get('@' + name)
+          instance_variable_get('@' + name)
+        end
+
+        class_variable_get('@@required_options') << name if
+          required == :required
+        class_variable_get('@@options')[name] = type
+      end
+
+      def setup_outputs
+        class_variable_get('@@outputs')
+      rescue
+        class_variable_set('@@outputs', {})
+      end
+
+      def setup_output(name, type)
+        define_method("#{name}") do
+          instance_variable_get("@#{name}")
+        end
+        class_variable_get('@@outputs')[name] = type
+      end
+
+      # Notes that this class has the specified option
+      #
+      # @param [String, Symbol] name Name of this option
+      # @param [Class] type Type required for this option - will be verified
+      # @param [optional, :optional, :required] required Is this option
+      # required to be set, or merely optional
+      def attr_option(name, type, required = :optional, &verifier)
+        name = name.to_s
+        setup_options
+        setup_option(name, type, required, verifier)
+      end
+
+      def attr_output(name, type)
+        name = name.to_s
+        setup_outputs
+        setup_output(name, type)
+      end
+
+      # Returns required set of options
+      # @return [Array<Option>] Required options for this class
+      def required_options
+        class_variable_get('@@required_options')
+      end
+
+      # Returns valid oset of options
+      # @return [Hash<String,Class>] Available set of options, with expected
+      # class for each.
+      def options
+        class_variable_get('@@options')
+      end
+
+      # Returns set of outputs that are set
+      # @return [Hash<String,Class>]] Outputs that are set on trigger, with
+      # types of each as values
+      def outputs
+        class_variable_get('@@outputs')
+      end
+
+      protected :attr_option, :attr_output
+      private :setup_options, :setup_option, :setup_output, :setup_outputs
+    end
+  end
+
+  # Used to store options - includes the expected type
+  # the name, and the value.  Also includes validation logic
+  # - the absence of validation logic in the value= operator is
+  # intentional, as there may be cases where you can set an invalid
+  # option value
+  class Option
+    attr_reader :name, :type
+    attr_accessor :value
+
+    def initialize(name, type, verifier = nil)
+      @type = type
+      @name = name
+      @verifier = if verifier
+                    verifier
+                  else
+                    true
+                  end
+    end
+
+    def valid?
+      !@value.nil? && @value.is_a?(@type) &&
+        (@verifier == true || @verifier.call(@value))
+    end
+  end
+
+  class OptionException < Exception
+  end
+end

data/lib/daf/datasources/yaml_data_source.rb

@@ -0,0 +1,53 @@
+require 'yaml'
+require 'daf/command'
+
+module DAF
+  # A datasource that is parsed out of a YAML file
+  # does not permit any dynamic updates, but useful
+  # for a basic command parser
+  class YAMLDataSource < CommandDataSource
+    attr_reader :monitor, :action
+
+    # Accepts the path of the YAML file to be parsed into
+    # commands - will throw a CommandException should it have
+    # invalid parameters
+    #
+    # @param filePath [String] Path for YAML file
+    def initialize(file_path)
+      configuration = YAML.load_file(file_path)
+      @action_class, @monitor_class = action_monitor_classes(configuration)
+      @monitor = @monitor_class.new(configuration['Monitor']['Options'])
+      @action = @action_class.new
+      @action_options = configuration['Action']['Options']
+    end
+
+    def action_options
+      # Attempt resolution to outputs of monitor
+      return @action_options unless @monitor_class.outputs.length > 0
+      action_options = @action_options.clone
+      @monitor_class.outputs.each do |output, _type|
+        action_options.each do |option_key, option_value|
+          action_options[option_key] =
+            option_value.gsub("{{#{output}}}", @monitor.send(output).to_s)
+        end
+      end
+      action_options
+    end
+
+    def action_monitor_classes(configuration)
+      begin
+        action_class = get_class(configuration['Action']['Type'])
+        monitor_class = get_class(configuration['Monitor']['Type'])
+      rescue
+        raise CommandException, 'Invalid Action or Monitor type'
+      end
+      [action_class, monitor_class]
+    end
+
+    def get_class(class_name)
+      Object.const_get(class_name)
+    end
+
+    protected :get_class, :action_monitor_classes
+  end
+end

data/lib/daf/monitor.rb

@@ -0,0 +1,27 @@
+require 'daf/configurable'
+
+module DAF
+  # Stores information relating to things being monitored
+  # sub-classes define specific criteria for when a monitor
+  # should 'go off'.  Has only one method, #on_trigger, that
+  # allows you to begin monitoring for an event
+  class Monitor
+    include Configurable
+
+    # Requires the set of options expected by this monitor
+    #
+    # @param options [Hash] The options in key/value format,
+    # the type of each option must match that expected or an
+    # exception will be raised
+    def initialize(options)
+      process_options(options)
+    end
+
+    # Begins monitoring for event, when event occurs will
+    # execute required block parameter
+    def on_trigger
+      block_until_triggered
+      yield
+    end
+  end
+end

data/lib/daf/monitors/file_update_monitor.rb

@@ -0,0 +1,46 @@
+require 'daf/monitor'
+
+module DAF
+  # Monitor that watches a file's last update time, and triggers when it changes
+  # includes several return outputs that can be used as well
+  class FileUpdateMonitor < Monitor
+    attr_option :path, String, :required do |val|
+      File.exist? val
+    end
+
+    attr_option :frequency, Integer, :required do |val|
+      val > 1
+    end
+
+    # @return [Time] The last modified time of file that caused trigger
+    attr_output :time, Time
+
+    # @return [String] The contents of the tile that caused trigger
+    attr_output :contents, String
+
+    def initialize(options)
+      super
+    end
+
+    def block_until_triggered
+      initial_modified_time = File.mtime(@path.value)
+      loop do
+        sleep @frequency.value
+        modified_time = File.mtime(@path.value)
+        next unless modified_time > initial_modified_time
+        @time = modified_time
+        @contents = contents_of_file(@path.value)
+        break
+      end
+    end
+
+    def contents_of_file(path)
+      file = File.open(path)
+      contents = file.read
+      file.close
+      contents
+    end
+
+    private :contents_of_file
+  end
+end

data/lib/daf/version.rb

@@ -0,0 +1,4 @@
+# DAF module version numbering
+module DAF
+  VERSION = '0.3.0'
+end

data/spec/action_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+# Test action to verify functionality
+class TestAction < DAF::Action
+  attr_accessor :success
+  alias_method :invoke, :success
+  attr_option :option, String
+end
+
+describe DAF::Action do
+  let(:test_action) { TestAction.new }
+  let(:options) { { 'option' => 'test' } }
+
+  it 'should be configurable' do
+    mixed_in = DAF::Action.ancestors.select { |o| o.class == Module }
+    expect(mixed_in).to include(DAF::Configurable)
+  end
+
+  it 'should have an activate method' do
+    expect(test_action).to respond_to(:activate)
+  end
+
+  it 'should return whatever invoke returns' do
+    test_action.success = 123
+    expect(test_action.activate(options)).to eq(123)
+  end
+
+  it 'should yield to a given block with invoke return value' do
+    test_action.success = 123
+    expect { |b| test_action.activate(options, &b) }
+      .to yield_with_args(123)
+  end
+
+  it 'should set option values' do
+    test_action.activate(options)
+    expect(test_action.option.value).to eq('test')
+  end
+end

data/spec/command_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe DAF::Command do
+  let(:datasource) do
+    datasource = double('DAF::CommandDataSource')
+    allow(datasource).to receive(:monitor).and_return(monitor)
+    allow(datasource).to receive(:action).and_return(action)
+    allow(datasource).to receive(:action_options).and_return({})
+    datasource
+  end
+  let(:monitor)  { double('DAF::Monitor') }
+  let(:action) { double('DAF::Action') }
+
+  context 'when initialize is called' do
+    it 'should accept a datasource' do
+      expect { DAF::Command.new(datasource) }.to_not raise_error
+    end
+  end
+
+  context 'when execute is called' do
+    before(:each) do
+      allow(action).to receive(:activate)
+      allow(monitor).to receive(:on_trigger).and_yield
+    end
+
+    let(:ithread) do
+      ithread = double('Thread')
+      allow(ithread).to receive(:kill)
+    end
+
+    let(:thread) do
+      thread = class_double('Thread').as_stubbed_const(
+        transfer_nested_constants: true)
+      allow(thread).to receive(:new).and_yield.and_return(ithread)
+      allow(thread).to receive(:kill)
+      allow(thread).to receive(:current).and_return(ithread)
+      allow(thread).to receive(:main).and_return(ithread)
+      thread
+    end
+
+    let(:command) do
+      DAF::Command.new(datasource)
+    end
+
+    it 'should create a new thread' do
+      expect(thread).to receive(:new)
+      command.execute
+    end
+
+    it 'should terminate the thread when cancel called' do
+      thread
+      expect(ithread).to receive(:kill)
+      command.execute
+      command.cancel
+    end
+
+    it 'should trigger on data source monitor' do
+      expect(monitor).to receive(:on_trigger).and_yield
+      command.execute
+      sleep(1)
+      command.cancel
+    end
+
+    it 'should active data source action on trigger' do
+      expect(action).to receive(:activate) # .with({})
+      command.execute
+      sleep(1)
+      command.cancel
+    end
+
+    it 'should loop when action is complete' do
+      expect(action).to receive(:activate).at_least(2).times
+      command.execute
+      sleep(1)
+      command.cancel
+    end
+  end
+end