action_command 0.1.3 → 0.1.4

data/doc/top-level-namespace.html

@@ -103,7 +103,7 @@
 </div>
 
     <div id="footer">
-  Generated on Fri Mar  4 10:20:14 2016 by
+  Generated on Mon Mar  7 14:27:17 2016 by
   <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
   0.8.7.6 (ruby-2.2.3).
 </div>

data/lib/action_command/executable.rb

@@ -34,6 +34,12 @@ module ActionCommand
     def rake_context?
       return root_context == ActionCommand::CONTEXT_RAKE
     end
+    
+    # @return true if this command was executed using ActionCommand.execute_api
+    def api_context?
+      return root_context == ActionCommand::CONTEXT_API
+    end
+    
 
     # @return true if this command is a child of another command
     def child_context?

data/lib/action_command/executable_transaction.rb

@@ -0,0 +1,27 @@
+module ActionCommand
+  # Root class for action commands that can be executed by this library.
+  # Override execute_internal to implement one, call one of the variants
+  # of ActionCommand.execute_... to execute one.
+  class ExecutableTransaction < Executable
+    
+    # starts a transaction only if we are not already within one.
+    def execute(result)
+      if ActiveRecord::Base.connection.open_transactions >= 1
+        super(result)
+      else
+        result.info('start_transaction')
+        ActiveRecord::Base.transaction do
+          super(result)
+          if result.ok?
+            result.info('end_transaction')
+          else
+            result.info('rollback_transaction')
+            raise ActiveRecord::Rollback, 'rollback transaction'
+          end
+        end
+      end
+    end
+    
+  end
+  
+end

data/lib/action_command/input_output.rb

@@ -126,6 +126,11 @@ module ActionCommand
       insert_io(@input, sym, desc, opts)
     end
     
+    # Defines output for a command
+    # @param sym [Symbol] symbol identifying the parameter
+    # @param desc [String] description for use by internal developers, or on a rake task with 
+    #   rake your_task_name[help]
+    # @param opts Optional arguments.
     def output(sym, desc, opts = {})
       insert_io(@output, sym, desc, opts)
     end

data/lib/action_command/log_parser.rb

@@ -0,0 +1,105 @@
+
+# Unnecessary comment for rubocop
+module ActionCommand
+  
+  # A single entry in the action command log
+  class LogMessage
+    
+    attr_accessor :sequence, :cmd, :kind, :msg, :key
+        
+    # Create a new log message
+    def populate(line, msg)
+      @line = line
+      @sequence = msg['sequence']
+      @depth = msg['depth']
+      @cmd = msg['cmd']
+      @kind = msg['kind']
+      @msg = msg['msg']
+      @key = msg['key']
+    end
+    
+    # @return the number of parents the current command has
+    def depth
+      return @depth
+    end
+    
+    # @return true if this command is the root command
+    def root?
+      return @depth == 0
+    end
+    
+    # @return the line that was used to create this message.
+    def line
+      return @line
+    end
+    
+    def key?(key)
+      return @key == key
+    end
+    
+    # @return true if the kinds equal (tolerant of string/symbol mismatch)
+    def kind?(kind)
+      kind = kind.to_s
+      return @kind == kind
+    end    
+    
+    # @return true if the cmds equal (tolerant of being passed a class)
+    def command?(cmd)
+      cmd = cmd.name if cmd.is_a? Class
+      return @cmd == cmd
+    end
+    
+    # @ return true if msgs equal
+    def match_message?(msg)
+      return @msg == msg unless msg.is_a? Hash
+      msg.each do |k, v|
+        k = k.to_s if k.is_a? Symbol
+        return false unless @msg.key?(k)
+        return false unless @msg[k] == v
+      end
+      return true
+    end
+  end
+  
+  # reads from a stream containing log statements, and returns
+  # LogMessage entries for them.
+  class LogParser
+    
+    # Create a new log parser for an IO subclass
+    def initialize(stream, sequence = nil)
+      @stream = stream
+      @sequence = sequence
+    end
+    
+    # Check if we have reached the end of the stream.
+    def eof?
+      return @stream.eof?
+    end    
+    
+    # Populates a message from the next line in the
+    def next(msg)
+      # be tolerant of the fact that there might be other 
+      # stuff in the log file.
+      next_line do |input, line|
+        if input.key?('sequence')
+          msg.populate(line, input) unless @sequence && @sequence != input['sequence']
+          return true
+        end
+      end
+      return false
+    end
+
+    private 
+    
+    def next_line
+      until @stream.eof?
+        line = @stream.readline
+        line.scan(/--\s+:\s+({.*})/) do |item|
+          input = JSON.parse(item[0])
+          yield input, line
+        end
+      end
+    end
+  end
+  
+end

data/lib/action_command/pretty_print_log_action.rb

@@ -0,0 +1,114 @@
+
+module ActionCommand
+  
+  # Action that parses a log and pretty prints the log,
+  # optionally filtering on a particular command sequence.
+  class PrettyPrintLogAction < Executable
+    attr_accessor :source, :dest, :sequence
+    
+    # specifies the input/output for this command
+    def self.describe_io
+      return ActionCommand.describe_io(self, 'Command that does some logging') do |io|
+        io.input(:source, 'Stream to read')
+        io.input(:sequence, 'sequence to filter on', OPTIONAL)
+        io.input(:dest, 'Optional output stream, defaults to STDOUT', OPTIONAL)
+      end
+    end
+    
+    # return the destination stream, default to STDOUT
+    def dest
+      @dest = STDOUT unless @dest
+      return @dest
+    end
+    
+    protected
+    
+
+    # Say hello to the specified person.
+    def execute_internal(_result)
+      item = LogMessage.new
+      parser = LogParser.new(@source, @sequence)
+      sequences = {}
+      # keep track of sequences, and when you complete one, then print out the 
+      # entire thing at once.
+      while parser.next(item)
+        if item.kind?(ActionCommand::LOG_KIND_COMMAND_OUTPUT) && item.root?
+          process_output(sequences, item)
+        else
+          process_other(sequences, item)
+        end  
+        item = LogMessage.new
+      end
+        
+      # print out any incomplete sequences
+      print_sequences(sequences)
+    end
+    
+    def process_other(sequences, item)
+      sequences[item.sequence] = [] unless sequences.key?(item.sequence)
+      sequences[item.sequence] << item
+    end    
+    
+    def process_output(sequences, item)
+      seq = sequences[item.sequence]
+      sequences.delete(item.sequence)
+      seq << item
+      print_sequence(seq)
+    end
+    
+    def print_sequences(sequences)
+      sequences.each do |_k, v|
+        print_sequence(v)
+      end
+    end
+    
+    def print_sequence(sequence)
+      sequence.each_with_index do |item, _i|
+        print_sequence_item(item)
+      end
+    end
+    
+    def print_sequence_item(item)
+      # indent
+      if item.kind?(ActionCommand::LOG_KIND_COMMAND_INPUT)
+        print_cmd_input(item)
+      elsif item.kind?(ActionCommand::LOG_KIND_COMMAND_OUTPUT)
+        print_cmd_output(item)
+      else
+        print_msg(item.depth + 1, item)
+      end
+    end
+
+    def print_cmd_output(item)
+      println(item.depth, 'output:')
+      print_msg(item.depth + 1, item)
+    end
+    
+    def print_cmd_input(item)
+      result = item.cmd
+      result << " (#{item.sequence})" if item.root?
+      println(item.depth, result)
+      println(item.depth + 1, 'input:')
+      print_msg(item.depth + 2, item)
+    end
+    
+    def print_msg(depth, item)
+      if item.msg.is_a? String
+        println(depth, item.msg)
+        return
+      end
+      
+      item.msg.each do |k, v|
+        println(depth, "#{k}: #{v}")
+      end
+    end
+    
+    def println(depth, line)
+      padding = ''.rjust(depth * 2)
+      dest.puts("#{padding}#{line}")
+    end
+      
+    
+  end
+  
+end

data/lib/action_command/result.rb

@@ -1,29 +1,79 @@
 
 module ActionCommand
+  
+  
   # The result of one or more commands being executed.
-  class Result
+  class Result # rubocop:disable Metrics/ClassLength
     # By default, a command is ok?
-    def initialize(logger)
-      @ok = true
+    def initialize
+      @result_code = RESULT_CODE_OK
       @values = [{}]
+      @logger = nil
+    end
+    
+    # set the logger for this result
+    def logger=(logger)
+      return unless logger
+      @sequence = SecureRandom.hex 
+      @stack = [] 
       @logger = logger
     end
+
+    # @return true if logging is enabled.
+    def logging?
+      return !@logger.nil?
+    end
+
+    # display an debugging message to the logger, if there is one.
+    # @yield return a message or hash
+    def debug(msg = nil)
+      if @logger
+        json = build_log(msg || yield, ActionCommand::LOG_KIND_DEBUG)
+        @logger.info(json)
+      end
+    end
+  
+    # display an informational message to the logger, if there is one.
+    # @yield return a message or hash
+    def info(msg = nil)
+      if @logger
+        json = build_log(msg || yield, ActionCommand::LOG_KIND_INFO)
+        @logger.info(json)
+      end
+    end
+  
+    # display an error message to the logger, if there is one.
+    def error(msg)
+      @logger.error(build_log(msg, ActionCommand::LOG_KIND_ERROR)) if @logger
+    end
   
     # Call this if your command implementation fails.  Sets
     # ok? to false on the result.
     # @param msg [String] message describing the failure.
     def failed(msg)
-      @ok = false
+      @result_code = RESULT_CODE_FAILED
+      error(msg)
+    end
+    
+    # Call this if your command implementation fails.  Sets
+    # ok? to false on the result.
+    # @param msg [String] message describing the failure.
+    # @param result_code [Integer]
+    def failed_with_code(msg, result_code)
+      @result_code = result_code
       error(msg)
     end
   
     # @return [Boolean] true, up until failed has been called at least once.
     def ok?
-      return @ok
+      return @result_code == RESULT_CODE_OK
     end
     
+    # @return [Integer] the current result code
+    attr_reader :result_code
+    
     # adds results under the subkey until pop is called
-    def push(key)
+    def push(key, cmd)
       return unless key
       old_cur = current
       if old_cur.key?(key)
@@ -32,12 +82,14 @@ module ActionCommand
         @values << {}
         old_cur[key] = @values.last
       end
+      @stack << { key: key, cmd: cmd } if @logger
     end
     
     # removes the current set of results from the stack.
     def pop(key)
       return unless key
       @values.pop
+      @stack.pop if @logger
     end
     
     # returns the current hash of values we are operating on.
@@ -50,6 +102,11 @@ module ActionCommand
       current[key] = val
     end
     
+    # return the unique sequence id for the commands under this result
+    def sequence
+      return @sequence
+    end
+    
     # determine if a key exists in the result.
     def key?(key)
       return current.key?(key)
@@ -59,18 +116,51 @@ module ActionCommand
     def [](key)
       return current[key]
     end
+    
+    # Used internally to log the input parameters to a command
+    def log_input(params)
+      return unless @logger
+      output = params.reject { |k, _v| internal_key?(k) }
+      log_info_hash(output, ActionCommand::LOG_KIND_COMMAND_INPUT)
+    end
 
-    # display an informational message to the logger, if there is one.
-    def info(msg)
-      @logger.info(msg) if @logger
+    # Used internally to log the output parameters for a command.
+    def log_output
+      return unless @logger
+      # only log the first level parameters, subcommands will log
+      # their own output.
+      output = current.reject { |k, v| v.is_a?(Hash) || internal_key?(k) }
+      log_info_hash(output, ActionCommand::LOG_KIND_COMMAND_OUTPUT) 
     end
-  
-    protected
-  
-    # display an error message to the logger, if there is one.
-    def error(msg)
-      @logger.error(msg) if @logger
+    
+    # Used internally to establish the class of the root command
+    def root_command(cls)
+      @stack << { key: nil, cmd: cls }  if @logger
+    end
+    
+
+    private 
+    
+    def internal_key?(k)
+      return k == :logger || k == :test || k == :parent
+    end
+
+    def log_info_hash(params, kind)
+      return unless @logger
+      @logger.info(build_log(params, kind))
+    end
+    
+    def build_log(msg, kind)
+      cur = @stack.last
+      out = { 
+        sequence: @sequence,
+        cmd: cur[:cmd].name,
+        depth: @stack.length - 1
+      }
+      out[:key] = cur[:key] if cur[:key]
+      out[:kind] = kind
+      out[:msg] = msg if msg
+      return JSON.generate(out)
     end
-  
   end
 end

data/lib/action_command/utils.rb

@@ -15,11 +15,6 @@ module ActionCommand
       return cls.find(item) if item.is_a? Integer
       return yield(item)
     end
-    
-    
-     
-    
-    
   end
   
 end

data/lib/action_command/version.rb

@@ -1,4 +1,4 @@
 module ActionCommand
   # Version of this Gem
-  VERSION = '0.1.3'.freeze
+  VERSION = '0.1.4'.freeze
 end

data/lib/action_command.rb

@@ -3,6 +3,8 @@ require 'action_command/result'
 require 'action_command/input_output'
 require 'action_command/executable'
 require 'action_command/utils'
+require 'action_command/log_parser'
+require 'action_command/pretty_print_log_action'
 
 # To use action command, create subclasses of ActionCommand::Executable
 # and run them using the ActionCommand.execute_... variants.
@@ -18,6 +20,32 @@ module ActionCommand
   # Used as root parent of command if we are executing it from rails (a controller, etc)
   CONTEXT_RAILS = :rails
   
+  # Used as a root element when the command is executed from an API context
+  CONTEXT_API = :api
+  
+  # Used if a result has had no failures
+  RESULT_CODE_OK = 0
+  
+  # Used as a generic result code for failure, if you do not provide
+  # a more specific one through {ActionCommand::Result#failed_with_code}
+  RESULT_CODE_FAILED = 1
+  
+  # log entry for the input to a commmand
+  LOG_KIND_COMMAND_INPUT   = :command_input
+  
+  # log entry for the output from a command
+  LOG_KIND_COMMAND_OUTPUT  = :command_output
+  
+  # info message from within a command
+  LOG_KIND_INFO            = :info
+
+  # debug message from within a command
+  LOG_KIND_DEBUG           = :debug
+  
+  # error message from within a command
+  LOG_KIND_ERROR           = :error
+  
+  
   # Used to create an optional parameter in describe_io
   OPTIONAL = { optional: true }.freeze
 
@@ -32,7 +60,7 @@ module ActionCommand
   
   # @return a new, valid, empty result.
   def self.create_result
-    return ActionCommand::Result.new(@@logger)
+    return ActionCommand::Result.new
   end
 
   # Execute a command at the root level of a testing context
@@ -83,6 +111,15 @@ module ActionCommand
     return ActionCommand.create_and_execute(cls, params, CONTEXT_RAILS, result)
   end
   
+  # Execute a command at the root level of an api context
+  # @param cls [ActionCommand::Executable] The class of an Executable subclass
+  # @param params [Hash] parameters used by the command.
+  # @return [ActionCommand::Result]
+  def self.execute_api(cls, params = {})
+    result = create_result
+    return ActionCommand.create_and_execute(cls, params, CONTEXT_API, result)
+  end
+  
   # Execute a child command, placing its results under the specified subkey
   # @param parent [ActionCommand::Executable] An instance of the parent command
   # @param cls [ActionCommand::Executable] The class of an Executable subclass
@@ -92,7 +129,7 @@ module ActionCommand
   # @param params [Hash] parameters used by the command.
   # @return [ActionCommand::Result]
   def self.execute_child(parent, cls, result, result_key, params = {})
-    result.push(result_key)
+    result.push(result_key, cls)
     ActionCommand.create_and_execute(cls, params, parent, result)
     result.pop(result_key)
     return result
@@ -115,14 +152,24 @@ module ActionCommand
 
   # Used internally, not for general purpose use.
   def self.create_and_execute(cls, params, parent, result)
+    check_params(cls, params)
+    params[:parent] = parent
+    result.logger = params[:logger] 
+    result.logger = @@logger unless params[:logger]
+    result.root_command(cls) if parent.is_a? Symbol
+    action = cls.new(params)
+    
+    result.log_input(params)
+    action.execute(result)
+    result.log_output   
+    return result
+  end
+  
+  def self.check_params(cls, params)
     raise ArgumentError, 'Expected params to be a Hash' unless params.is_a? Hash
     
     unless cls.is_a?(Class) && cls.ancestors.include?(ActionCommand::Executable)
       raise ArgumentError, 'Expected an ActionCommand::Executable as class'
     end
-    
-    params[:parent] = parent
-    action = cls.new(params)
-    return action.execute(result)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: action_command
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Chris Jones
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-03-04 00:00:00.000000000 Z
+date: 2016-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -192,6 +206,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Simple implementation of command pattern focused on reuse in multiple
   contexts
 email:
@@ -200,6 +242,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".byebug_history"
 - ".codeclimate.yml"
 - ".gitignore"
 - ".rspec"
@@ -236,7 +279,10 @@ files:
 - doc/top-level-namespace.html
 - lib/action_command.rb
 - lib/action_command/executable.rb
+- lib/action_command/executable_transaction.rb
 - lib/action_command/input_output.rb
+- lib/action_command/log_parser.rb
+- lib/action_command/pretty_print_log_action.rb
 - lib/action_command/result.rb
 - lib/action_command/utils.rb
 - lib/action_command/version.rb