fiksu-af 1.1.0

data/lib/fiksu-af/option_parser/option_check.rb

@@ -0,0 +1,66 @@
+module ::Af::OptionParser
+  class OptionCheck < InstanceVariableSetter
+    FACTORY_SETTABLES = [
+                          :action,
+                          :targets,
+                          :error_message,
+                          :block
+                        ]
+
+    attr_accessor *FACTORY_SETTABLES
+    attr_accessor :var_name
+
+    def initialize(var_name, parameters = {})
+      super(parameters)
+      @var_name = var_name
+    end
+
+    #-------------------------
+    # *** Instance Methods ***
+    #+++++++++++++++++++++++++
+
+    def set_instance_variables(parameters = {})
+      super(parameters, FACTORY_SETTABLES)
+    end
+
+    def merge(that_option)
+      super(that_option, FACTORY_SETTABLES)
+    end
+
+    # This methods validates the selected options based
+    # on the chosen action.
+    #
+    # Available actions: requires, excludes
+    #
+    # If an invalidation occurs, an OptionCheckError is raised
+    # with a specific message.
+    def validate
+      # If an option_check is used, the target_variable must be instantiated
+      if target_container.try(target_variable.to_sym).blank?
+        raise OptionCheckError.new("Option --#{target_variable} must be specified")
+      end
+
+      # If an option_check is used, an array of options must be given
+      if targets.empty?
+        raise OptionCheckError.new("An array of #{action.to_s[0..-2]}d options must be specified")
+      end
+
+      if action == :requires
+        # Each target option must be specified
+        targets.each do |target|
+          if target_container.try(target.to_sym).blank?
+            raise OptionCheckError.new("You must specify these options: --#{targets.join(', --')}")
+          end
+        end
+      elsif action == :excludes
+        # None of the target options can be specified
+        targets.each do |target|
+          if target_container.try(target.to_sym).present?
+            raise OptionCheckError.new("You cannot specify these options: --#{targets.join(', --')}")
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/fiksu-af/option_parser/option_finder.rb

@@ -0,0 +1,82 @@
+module ::Af::OptionParser
+  class OptionFinder
+
+    def initialize(class_path)
+      @class_path = class_path
+      @all_options = {}
+      @all_option_groups = {}
+      @all_option_checks = {}
+      @all_option_selects = {}
+
+      # class_path:
+      #  Class: include class and all its ancestors options
+      @class_path.each do |klass|
+        klass.ancestors.reverse.each do |ancestor|
+          option_store = OptionStore.find(ancestor)
+          if option_store
+            options = option_store.options
+            if options.present?
+              options.each do |long_name, option|
+                merged_option = @all_options[long_name] ||= Option.new(long_name)
+                merged_option.set_instance_variables(option)
+              end
+            end
+
+            option_groups = option_store.option_groups
+            if option_groups.present?
+              option_groups.each do |name, option_group|
+                merged_option_group = @all_option_groups[name] ||= OptionGroup.new(name)
+                merged_option_group.set_instance_variables(option_group)
+              end
+            end
+
+            option_checks = option_store.option_checks
+            if option_checks.present?
+              option_checks.each do |name, option_check|
+                merged_option_check = @all_option_checks[name] ||= OptionCheck.new(name)
+                merged_option_check.set_instance_variables(option_check)
+              end
+            end
+
+            option_selects = option_store.option_selects
+            if option_selects.present?
+              option_selects.each do |name, option_select|
+                merged_option_select = @all_option_selects[name] ||= OptionSelect.new(name)
+                merged_option_select.set_instance_variables(option_select)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    #-------------------------
+    # *** Instance Methods ***
+    #+++++++++++++++++++++++++
+
+    def all_options
+      return @all_options.values
+    end
+
+    def all_option_groups
+      return @all_option_groups.values
+    end
+
+    def all_option_checks
+      return @all_option_checks.values
+    end
+
+    def all_option_selects
+      return @all_option_selects.values
+    end
+
+    def all_options_by_long_name
+      return @all_options
+    end
+
+    def find_option(long_name)
+      return all_options_by_long_name[long_name]
+    end
+
+  end
+end

data/lib/fiksu-af/option_parser/option_group.rb

@@ -0,0 +1,37 @@
+module ::Af::OptionParser
+  class OptionGroup
+    FACTORY_SETTABLES = [:title,
+                         :priority,
+                         :description,
+                         :hidden,
+                         :disabled]
+    attr_accessor *FACTORY_SETTABLES
+    attr_accessor :group_name
+
+    def initialize(group_name, parameters = {})
+      @group_name = group_name
+      set_instance_variables(parameters)
+    end
+
+    #-------------------------
+    # *** Instance Methods ***
+    #+++++++++++++++++++++++++
+
+    def set_instance_variables(parameters = {})
+      parameters.select do |name,value|
+        FACTORY_SETTABLES.include? name
+      end.each do |name,value|
+        instance_variable_set("@#{name}", value)
+      end
+    end
+
+    def merge(that_option_group)
+      FACTORY_SETTABLES.each do |name|
+        if that_option_group.instance_variable_defined?("@#{name}")
+          self.send("#{name}=", that_option_group.send(name))
+        end
+      end
+    end
+
+  end
+end

data/lib/fiksu-af/option_parser/option_select.rb

@@ -0,0 +1,68 @@
+module ::Af::OptionParser
+  class OptionSelect < InstanceVariableSetter
+    FACTORY_SETTABLES = [
+                          :action,
+                          :targets,
+                          :error_message
+                        ]
+
+    attr_accessor *FACTORY_SETTABLES
+    attr_accessor :var_name
+
+    def initialize(var_name, parameters = {})
+      super(parameters)
+      @var_name = var_name
+    end
+
+    #-------------------------
+    # *** Instance Methods ***
+    #+++++++++++++++++++++++++
+
+    def set_instance_variables(parameters = {})
+      super(parameters, FACTORY_SETTABLES)
+    end
+
+    def merge(that_option)
+      super(that_option, FACTORY_SETTABLES)
+    end
+
+    # This methods validates the selected options based
+    # on the chosen action.
+    #
+    # Available actions: one_of, none_or_one_of, one_or_more_of
+    #
+    # If an invalidation occurs, an OptionSelectError is raised
+    # with a specific message.
+    def validate
+      # If an option_select is used, an array of options must be given
+      if targets.blank?
+        raise OptionSelectError.new("An array of options must be specified")
+      end
+
+      # Populate the options_set array with all instantiated class/instance variables
+      options_set = []
+      targets.each do |target|
+        if target_container.try(target.to_sym).present?
+          options_set << target
+        end
+      end
+
+      # Assign instantiated options to an instance variable
+      if options_set.size == 1
+        value = options_set.first
+      else
+        value = options_set
+      end
+      target_container.instance_variable_set("@#{target_variable}", value)
+
+      if action == :one_of && options_set.size != 1
+        raise OptionSelectError.new("You must specify only one of these options: --#{targets.join(', --')}")
+      elsif action == :none_or_one_of && options_set.size > 1
+        raise OptionSelectError.new("You must specify no more than one of these options: --#{targets.join(', --')}")
+      elsif action == :one_or_more_of && options_set.size < 1
+        raise OptionSelectError.new("You must specify at least one of these options: --#{targets.join(', --')}")
+      end
+    end
+
+  end
+end

data/lib/fiksu-af/option_parser/option_store.rb

@@ -0,0 +1,89 @@
+module ::Af::OptionParser
+  class OptionStore
+    attr_reader :options,
+                :option_groups,
+                :containing_class,
+                :option_checks,
+                :option_selects
+
+    @@option_stores = {}
+
+    def initialize(containing_class)
+      @containing_class = containing_class
+      @options = {}
+      @option_groups = {}
+      @option_checks = {}
+      @option_selects = {}
+    end
+
+    #----------------------
+    # *** Class Methods ***
+    #++++++++++++++++++++++
+
+    def self.find(containing_class)
+      return @@option_stores[containing_class]
+    end
+
+    def self.factory(containing_class)
+      @@option_stores[containing_class] ||= new(containing_class)
+      return @@option_stores[containing_class]
+    end
+
+    #-------------------------
+    # *** Instance Methods ***
+    #+++++++++++++++++++++++++
+
+    def find_option(long_name)
+      return options[long_name]
+    end
+
+    def construct_option(long_name)
+      @options[long_name] ||= {}
+      return @options[long_name]
+    end
+
+    def get_option(long_name)
+      return find_option(long_name) || construct_option(long_name)
+    end
+
+    def find_option_group(long_name)
+      return option_groups[long_name]
+    end
+
+    def construct_option_group(name)
+      @option_groups[name] ||= {}
+      return @option_groups[name]
+    end
+
+    def get_option_group(long_name)
+      return find_option_group(long_name) || construct_option_group(long_name)
+    end
+
+    def find_option_check(var_name)
+      return option_checks[var_name]
+    end
+
+    def construct_option_check(var_name)
+      @option_checks[var_name] ||= {}
+      return @option_checks[var_name]
+    end
+
+    def get_option_check(var_name)
+      return find_option_check(var_name) || construct_option_check(var_name)
+    end
+
+    def find_option_select(var_name)
+      return option_selects[var_name]
+    end
+
+    def construct_option_select(var_name)
+      @option_selects[var_name] ||= {}
+      return @option_selects[var_name]
+    end
+
+    def get_option_select(var_name)
+      return find_option_select(var_name) || construct_option_select(var_name)
+    end
+
+  end
+end

data/lib/fiksu-af/option_parser/option_type.rb

@@ -0,0 +1,59 @@
+module ::Af::OptionParser
+  class OptionType
+    attr_reader :name,
+                :short_name,
+                :argument_note,
+                :evaluate_method,
+                :handler_method
+
+    @@types = []
+
+    def initialize(name, short_name, argument_note, evaluate_method, handler_method)
+      @name = name
+      @short_name = short_name
+      @argument_note = argument_note
+      @evaluate_method = evaluate_method
+      @handler_method = handler_method
+      @@types << self
+    end
+
+    #----------------------
+    # *** Class Methods ***
+    #++++++++++++++++++++++
+
+    def self.types
+      return @@types
+    end
+
+    def self.valid_option_type_names
+      return types.map(&:short_name)
+    end
+
+    def self.find_by_value(value)
+      return types.find{ |t| t.handle?(value) }
+    end
+
+    def self.find_by_short_name(short_name)
+      return types.find{ |t| t.short_name == short_name }
+    end
+
+    #-------------------------
+    # *** Instance Methods ***
+    #+++++++++++++++++++++++++
+
+    def evaluate_argument(argument, option)
+      if @evaluate_method.is_a? Symbol
+        return argument.send(@evaluate_method)
+      end
+      return @evaluate_method.call(argument, option)
+    end
+
+    def handle?(value)
+      if @handler_method.is_a? Class
+        return value.is_a? @handler_method
+      end
+      return @handler_method.call(value)
+    end
+
+  end
+end

data/lib/fiksu-af/option_parser.rb

@@ -0,0 +1,145 @@
+require 'fiksu-af/option_parser/columnizer.rb'
+require 'fiksu-af/option_parser/dsl.rb'
+require 'fiksu-af/option_parser/get_options.rb'
+require 'fiksu-af/option_parser/helper.rb'
+require 'fiksu-af/option_parser/interface.rb'
+require 'fiksu-af/option_parser/instance_variable_setter.rb'
+require 'fiksu-af/option_parser/option.rb'
+require 'fiksu-af/option_parser/option_check.rb'
+require 'fiksu-af/option_parser/option_select.rb'
+require 'fiksu-af/option_parser/option_group.rb'
+require 'fiksu-af/option_parser/option_type.rb'
+require 'fiksu-af/option_parser/option_store.rb'
+require 'fiksu-af/option_parser/option_finder.rb'
+
+module Af::OptionParser
+  include Interface
+
+  class Error < ArgumentError; end
+  class MisconfiguredOptionError < Error; end
+  class BadChoiceError < Error; end
+  class UndeterminedArgumentTypeError < Error; end
+  class OptionCheckError < Error; end
+  class OptionSelectError < Error; end
+
+  def self.included(base)
+    add_option_types
+    base.extend(Dsl)
+  end
+
+  def self.add_option_types
+    OptionType.new(:Switch, :switch, "", lambda {|argument,option|
+                     if ["t", "true", "yes", "on"].include?(argument.to_s.downcase)
+                       return true
+                     elsif ["f", "false", "no", "off"].include?(argument.to_s.downcase)
+                       return false
+                     else
+                       if option.default_value == nil
+                         return true
+                       else
+                         return !option.default_value
+                       end
+                     end
+                   }, lambda{ |value| return (value.is_a?(TrueClass) || value.is_a?(FalseClass)) })
+    OptionType.new(:Boolean, :boolean, "", lambda {|argument,option|
+                     if ["t", "true", "yes", "on"].include?(argument.to_s.downcase)
+                       return true
+                     elsif ["f", "false", "no", "off"].include?(argument.to_s.downcase)
+                       return false
+                     else
+                       if option.default_value == nil
+                         return true
+                       else
+                         return !option.default_value
+                       end
+                     end
+                   }, lambda{ |value| return (value.is_a?(TrueClass) || value.is_a?(FalseClass)) })
+    OptionType.new(:Int, :int, "INTEGER", :to_i, Fixnum)
+    OptionType.new(:Integer, :integer, "INTEGER", :to_i, Fixnum)
+    OptionType.new(:Float, :float, "NUMBER", :to_f, Float)
+    OptionType.new(:Number, :number, "NUMBER", :to_f, Float)
+    OptionType.new(:String, :string, "STRING", :to_s, String)
+    OptionType.new(:Uri, :uri, "URI", lambda {|argument, option_parser| return URI.parse(argument) }, URI::HTTP)
+    OptionType.new(:Date, :date, "DATE", lambda {|argument, option_parser| return Time.zone.parse(argument).to_date }, Date)
+    OptionType.new(:Time, :time, "TIME", lambda {|argument, option_parser| return Time.zone.parse(argument) }, Time)
+    OptionType.new(:DateTime, :datetime, "DATETIME", lambda {|argument, option_parser| return Time.zone.parse(argument) }, DateTime)
+    OptionType.new(:Choice,
+                   :choice,
+                   "CHOICE",
+                   lambda { |argument, option_parser|
+                     choice = argument.to_sym
+                     choices = option_parser.choices
+                     unless choices.blank?
+                       unless choices.include? choice
+                         raise BadChoiceError.new("invalid choice '#{choice}' not in list of choices: #{choices.map(&:to_s).join(', ')}")
+                       end
+                     end
+                     return choice
+                   }, Symbol)
+    OptionType.new(:Hash,
+                   :hash,
+                   "K1=V1,K2=V2,K3=V3...",
+                   lambda { |argument, option_parser| return Hash[argument.split(',').map{ |ai| ai.split('=') }] },
+                   Hash)
+    OptionType.new(:Ints,
+                   :ints,
+                   "INT1,INT2,INT3...",
+                   lambda { |argument, option_parser| return argument.split(',').map(&:to_i) },
+                   lambda { |value| return value.class == Array && value.first.class == Fixnum })
+    OptionType.new(:Integers,
+                   :integers,
+                   "INT1,INT2,INT3...",
+                   lambda { |argument, option_parser| return argument.split(',').map(&:to_i) },
+                   lambda { |value| return value.class == Array && value.first.class == Fixnum })
+    OptionType.new(:Floats,
+                   :floats,
+                   "NUM1,NUM2,NUM3...",
+                   lambda { |argument, option_parser| return argument.split(',').map(&:to_f) },
+                   lambda { |value| return value.class == Array && value.first.class == Float })
+    OptionType.new(:Numbers,
+                   :numbers,
+                   "NUM1,NUM2,NUM3...",
+                   lambda { |argument, option_parser| return argument.split(',').map(&:to_f) },
+                   lambda { |value| return value.class == Array && value.first.class == Float })
+    OptionType.new(:Strings,
+                   :strings,
+                   "STR1,STR2,STR3...",
+                   lambda { |argument, option_parser| return argument.split(',').map(&:to_s) },
+                   lambda { |value| return value.class == Array && value.first.class == String })
+    OptionType.new(:Uris,
+                   :uris,
+                   "URL1,URL2,URL3...",
+                   lambda { |argument, option_parser| return argument.split(',').map{ |a| URI.parse(a)} },
+                   lambda { |value| return value.class == Array && value.first.class == URI::HTTP })
+    OptionType.new(:Dates,
+                   :dates,
+                   "DATE1,DATE2,DATE3...",
+                   lambda { |argument, option_parser| return argument.split(',').map{ |a| Time.zone.parse(a).to_date} },
+                   lambda { |value| return value.class == Array && value.first.class == Date })
+    OptionType.new(:Times,
+                   :times,
+                   "TIME1,TIME2,TIME3...",
+                   lambda { |argument, option_parser| return argument.split(',').map{ |a| Time.zone.parse(a) } },
+                   lambda { |value| return value.class == Array && value.first.class == Time })
+    OptionType.new(:DateTimes,
+                   :datetimes,
+                   "TIME1,TIME2,TIME3...",
+                   lambda { |argument, option_parser| return argument.split(',').map{ |a| Time.zone.parse(a) } },
+                   lambda { |value| return value.class == Array && value.first.class == DateTime })
+    OptionType.new(:Choices,
+                   :choices,
+                   "CHOICE1,CHOICE2,CHOICE3...",
+                   lambda { |argument, option_parser|
+                     choice_list = argument.split(',').map(&:to_sym)
+                     choices = option_parser.choices
+                     unless choices.blank?
+                       choice_list.each do |choice|
+                         unless choices.include? choice
+                           raise BadChoiceError.new("invalid choice '#{choice}' not in list of choices: #{choices.map(&:to_s).join(', ')}")
+                         end
+                       end
+                     end
+                     return choice_list
+                   }, lambda {|value| return value.class == Array && value.first.class == Symbol })
+  end
+end

data/lib/fiksu-af/q_thread/base.rb

@@ -0,0 +1,20 @@
+module Af::QThread
+  class Base < Thread
+    attr_reader :queue
+
+    def initialize
+      @queue = Queue.new
+      super
+    end
+
+    include ::Af::QThread::Interface
+
+    def request_termination(from = Thread.current)
+      post_data_message(:terminate, from)
+    end
+
+    def kick_start(from = Thread.current)
+      post_data_message(:kick_start, from)
+    end
+  end
+end

data/lib/fiksu-af/q_thread/interface.rb

@@ -0,0 +1,23 @@
+module Af::QThread
+  module Interface
+    def has_message?
+      return !queue.empty?
+    end
+
+    def read_message
+      return queue.pop
+    end
+
+    def post_message(message)
+      queue << message
+    end
+
+    def requeue(message)
+      post_message(message)
+    end
+
+    def post_data_message(data, from = Thread.current)
+      post_message(::Af::QThread::Message.new(data, from))
+    end
+  end
+end

data/lib/fiksu-af/q_thread/message.rb

@@ -0,0 +1,14 @@
+module Af::QThread
+  class Message
+    attr_accessor :from, :data, :msg_id
+    def initialize(data, from = Thread.current)
+      @from = from
+      @data = data
+      @msg_id = self.class.new_msg_id
+    end
+
+    def self.new_msg_id
+      return UUID.new
+    end
+  end
+end

data/lib/fiksu-af/q_thread/message_handler.rb

@@ -0,0 +1,30 @@
+module Af::QThread
+  class MessageHandler
+    attr_reader :thread
+
+    def initialize(thread)
+      @thread = thread
+    end
+
+    def self.run(thread = Thread.current)
+      return new(thread).run
+    end
+
+    def run
+      process_messages
+    end
+
+    def process_messages
+      while true
+        message = thread.read_message
+        break if message.data == :terminate
+        response = process_message(message)
+        message.from.post_data_message(response, thread)
+      end
+    end
+
+    def process_message(message)
+      return nil
+    end
+  end
+end

data/lib/fiksu-af/tcp_command/client.rb

@@ -0,0 +1,49 @@
+module Af::TCPCommand
+  class Client
+    include ::Af::Application::Proxy
+
+    attr_reader :client, :server_hostname, :server_port
+
+    def initialize(server_hostname, server_port)
+      @server_hostname = server_hostname
+      @server_port = server_port
+      @client = TCPSocket.new(server_hostname, server_port)
+    end
+
+    def logger
+      return af_logger(self.class.name)
+    end
+
+    def command_reader
+      return client.readline.chomp
+    end
+
+    def command_dispatcher(line)
+      logger.debug_fine "process command: #{line}"
+    end
+
+    def reply_to_server(line)
+      client.write("#{line}\n")
+    end
+
+    def ready
+      reply_to_server("ready")
+    end
+
+    def serve
+      while true
+        logger.debug_medium "READY!"
+        ready
+        begin
+          line = command_reader
+          logger.debug_fine "working on: #{line}"
+          command_dispatcher(line)
+        rescue EOFError
+          logger.warn "master closed connection: #{client.inspect}"
+          client.close
+          break
+        end
+      end
+    end
+  end
+end