coral_plan 0.1.1

data/lib/coral_plan/command.rb

@@ -0,0 +1,188 @@
+
+module Coral
+module Plan
+class Command < Command
+ 
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+
+  def initialize(options = {})
+    super(options)    
+    @plan = ( options.has_key?(:plan) ? options[:plan] : nil )
+  end
+     
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  def command=command
+    super(command)
+    @plan.set_command(@name, "command", command) if @plan
+  end
+  
+  #---
+  
+  def vagrant=command
+    super(command)
+    @plan.set_command(@name, "vagrant", command) if @plan
+  end
+  
+  #---
+  
+  def cloud=command
+    super(command)    
+    @plan.set_command(@name, "cloud", command) if @plan
+  end
+  
+  #---
+  
+  def args=args
+    super(args)
+    @plan.set_command(@name, "args", @properties[:args]) if @plan
+  end
+  
+  #---
+  
+  def flags=flags
+    super(flags)
+    @plan.set_command(@name, "flags", @properties[:flags]) if @plan
+  end
+  
+  #---
+  
+  def data=data
+    super(data)
+    @plan.set_command(@name, "data", @properties[:data]) if @plan
+  end
+  
+  #---
+  
+  def subcommand=subcommand
+    super(subcommand)
+    @plan.set_command(@name, "subcommand", @properties[:subcommand]) if @plan
+  end
+  
+  #---
+  
+  def events
+    events = {}
+    if @plan
+      event_types = @plan.command(@name, 'events', [], :array)
+      @plan.events.each do |name, event|
+        if event_types.include?(event.type)
+          events[name] = @plan.events[name]
+        end
+      end
+    end
+    return events
+  end
+   
+  #---
+  
+  def events=events
+    @plan.set_command(@name, "events", events) if @plan
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Command functions
+  
+  def build(components = {}, overrides = nil, override_key = false)
+    if overrides && ! overrides.empty?
+      overrides = translate_events(overrides)
+    end
+    return super(translate_events(components), overrides, override_key)
+  end
+  
+  #---
+  
+  def exec!(options = {}, action = nil)
+    triggered_events = {}
+    action_info      = action
+    
+    if action && ! action.is_a?(Hash)
+      action_info = action.export
+    end
+    
+    success = super(options, action_info) do |line|
+      result = true
+      prefix = false
+      
+      if @plan
+        @plan.events.each do |name, event|
+          if events.has_key?(name) && event.check(line)
+            prefix = 'EVENT'
+            triggered_events[name] = event
+          end
+        end
+      end
+      
+      if block_given?
+        result = yield(line)
+        
+        if result && result.is_a?(Hash)
+          result = result[:success]                 
+        end
+      end
+      prefix ? { :success => result, :prefix => prefix } : result
+    end
+       
+    if @plan && action
+      if success
+        action.trigger_success.each do |name|
+          triggered_events[name] = @plan.events[name]  
+        end
+      else
+        action.trigger_failure.each do |name|
+          triggered_events[name] = @plan.events[name]  
+        end
+      end
+    end
+    
+    return ( success ? triggered_events : nil )
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def translate_events(data, options = [ :exit ])
+    if @plan && data && data.is_a?(Hash) && data.has_key?(:data)
+      data[:data].each do |key, value|
+        # Action with command specific overrides
+        if value.is_a?(Hash)
+          value.each do |sub_key, sub_value|
+            if options.include?(sub_key) && @plan.command(key, 'coral', false)
+              events = []
+              array(sub_value.split(',')).each do |event_name|
+                if @plan.events.has_key?(event_name)
+                  events << @plan.events[event_name].export
+                else
+                  events << event_name
+                end
+              end
+              data[:data][key][sub_key] = events.join(',')
+            end
+          end
+        # Command or Action with overrides for all commands
+        elsif options.include?(key)
+          if data.has_key?(:commands)
+            array(data[:commands]).each do |command_name|
+              return data unless @plan.command(command_name, 'coral', false)
+            end
+          end
+      
+          events = []
+          array(value.split(',')).each do |event_name|
+            if @plan.events.has_key?(event_name)              
+              events << @plan.events[event_name].export
+            else
+              events << event_name
+            end
+          end
+          data[:data][key] = events.join(',')          
+        end
+      end
+    end
+    return data
+  end  
+end
+end
+end

data/lib/coral_plan/event.rb

@@ -0,0 +1,69 @@
+
+module Coral
+module Plan
+class Event < Event
+  
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def self.instance(options = {}, build_hash = false, keep_array = false)
+    return instance!(options, build_hash, keep_array) do |type, info|
+      type == :plan ? info[:object] : create(type, info)
+    end
+  end
+  
+  #---
+  
+  def initialize(options = {})
+    super(options)    
+    @plan = ( options.has_key?(:plan) ? options[:plan] : nil )
+  end
+    
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  def set_properties(data)
+    super(data)
+    @plan.set_event(@name, nil, @properties) if @plan
+    return self
+  end
+  
+  #---
+  
+  def set_property(name, value)
+    super(data)
+    @plan.set_event(@name, name, @properties[name]) if @plan
+    return self
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def self.build_info(data = {})
+    return build_info!(data) do |element|
+      event = {}
+             
+      case element        
+      when String
+        if @plan && @plan.events.has_key?(element)
+          event[:type]   = :plan
+          event[:object] = @plan.events[element]
+        else
+          event = split_event_string(element)
+        end        
+      when Hash          
+        event = element
+      end
+      
+      if @plan
+        event[:delegate] = self.new({
+          :name => element[:name],
+          :plan => @plan,
+        })
+      end      
+      event
+    end
+  end
+end
+end
+end

data/lib/coral_plan.rb

@@ -0,0 +1,75 @@
+
+home = File.dirname(__FILE__)
+
+$:.unshift(home) unless
+  $:.include?(home) || $:.include?(File.expand_path(home))
+  
+#-------------------------------------------------------------------------------
+  
+require 'rubygems'
+require 'coral_core'
+
+#---
+
+# Include data model
+[ :event, :command, :action, :base ].each do |name| 
+  require File.join('coral_plan', name.to_s + '.rb') 
+end
+
+#*******************************************************************************
+# Coral Execution Plan Library
+#
+# This provides the ability to create repeatable execution plans that can be
+# loaded from and stored into files, among other things...
+#
+# Author::    Adrian Webb (mailto:adrian.webb@coraltech.net)
+# License::   GPLv3
+module Coral
+  
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+
+  def self.create_plan(name, options = {})
+    return Coral::Plan.create(name, options)
+  end
+  
+  #---
+  
+  def self.delete_plan(name)
+    return Coral::Plan.delete(name)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Accessors / Modifiers
+  
+  def self.plan(name)
+    return Coral::Plan[name]
+  end
+
+#*******************************************************************************
+
+module Plan
+  
+  VERSION = File.read(File.join(File.dirname(__FILE__), '..', 'VERSION'))
+  
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def self.create(name, options = {})
+    return Coral::Plan::Base.create(name, options)
+  end
+  
+  #---
+  
+  def self.delete(name) 
+    return Coral::Plan::Base.delete(name)  
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Accessors / Modifiers
+ 
+  def self.[](name)
+    return Coral::Plan::Base[name]  
+  end
+end
+end

metadata

@@ -0,0 +1,206 @@
+--- !ruby/object:Gem::Specification 
+name: coral_plan
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Adrian Webb
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-02-07 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: coral_core
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 0
+        - 1
+        version: "0.1"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 2
+        version: "1.2"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 2
+        - 10
+        version: "2.10"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rdoc
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 3
+        - 12
+        version: "3.12"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 1
+        - 8
+        version: "1.8"
+  type: :development
+  version_requirements: *id005
+description: |-
+  = coral_plan
+  
+  This library provides the ability to create, load, execute, and save 
+  execution plans.
+  
+  The Coral Plan library contains a system that defines execution plans of 
+  CLI commands.  The goal is to make it easy to create, edit, load, execute,
+  and save these plans in a machine readable format (ie; JSON).  The system 
+  is composed of Events, Commands, Actions, and of course Plans. There are a
+  few simple rules:
+      
+  1. All plans begin with a Command but may have more Commands defined
+     that act in sequence unless there are errors with previous commands.
+      
+  2. Commands can trigger Events of various types, where Events are reading
+     and checking (ie; Regular expressions) Command output line by line.
+         
+  3. Events have different criteria for measuring success and will have 
+     different fields.  For example, a Regexp event contains a 'pattern'
+     field.
+         
+  4. Actions listen for Events and run Commands, with the ability to override
+     default Command parameters.  Actions may also generate Events on either
+     successful execution or failure which can trigger other Actions.
+         
+  Note:  This library is still very early in development!
+  
+  == Contributing to coral_plan
+   
+  * Check out the latest master to make sure the feature hasn't been implemented 
+    or the bug hasn't been fixed yet.
+  * Check out the issue tracker to make sure someone already hasn't requested 
+    it and/or contributed it.
+  * Fork the project.
+  * Start a feature/bugfix branch.
+  * Commit and push until you are happy with your contribution.
+  * Make sure to add tests for it. This is important so I don't break it in a 
+    future version unintentionally.
+  * Please try not to mess with the Rakefile, version, or history. If you want 
+    to have your own version, or is otherwise necessary, that is fine, but 
+    please isolate to its own commit so I can cherry-pick around it.
+  
+  == Copyright
+  
+  Licensed under GPLv3.  See LICENSE.txt for further details.
+  
+  Copyright (c) 2013  Adrian Webb <adrian.webb@coraltech.net>
+  Coral Technology Group LLC
+email: adrian.webb@coraltech.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/coral_plan.rb
+- lib/coral_plan/action.rb
+- lib/coral_plan/base.rb
+- lib/coral_plan/command.rb
+- lib/coral_plan/event.rb
+homepage: http://github.com/coraltech/ruby-coral_plan
+licenses: 
+- GPLv3
+post_install_message: 
+rdoc_options: 
+- --title
+- Coral Execution Plan library
+- --main
+- README.rdoc
+- --line-numbers
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 53
+      segments: 
+      - 1
+      - 8
+      - 1
+      version: 1.8.1
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: coral_plan
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Provides the ability to create, load, execute, and save execution plans
+test_files: []
+
+has_rdoc: