ul-wukong 4.1.0

data/lib/wukong/local/stdio_driver.rb

@@ -0,0 +1,104 @@
+module Wukong
+  module Local
+
+    # A class for driving processors over the STDIN/STDOUT protocol.
+    #
+    # Relies on EventMachine's [LineAndTextProtocol](http://eventmachine.rubyforge.org/EventMachine/Protocols/LineText2.html).
+    class StdioDriver < EM::P::LineAndTextProtocol
+      
+      include DriverMethods
+      include Logging
+
+      #
+      # == Startup == 
+      #
+
+      # Start a new StdioDriver.
+      #
+      # @param [Symbol] the name of the processor or dataflow to drive
+      # @param [Configliere::Param] settings the settings to use
+      def self.start(label, settings = {})
+        EM.attach($stdin, self, label, settings)
+      end
+
+      # :nodoc:
+      def initialize(label, settings)
+        super
+        construct_dataflow(label, settings)
+      end
+
+      # Ensures that $stdout is synced.
+      def setup()
+        $stdout.sync
+      end
+
+      # Adds signal traps for SIGINT and SIGTERM to Ensure we capture
+      # C-c and friends, stop the EventMachine reactor, &c.
+      def self.add_signal_traps
+        Signal.trap('INT')  { log.info 'Received SIGINT. Stopping.'  ; EM.stop }
+        Signal.trap('TERM') { log.info 'Received SIGTERM. Stopping.' ; EM.stop }
+      end
+
+      # Called by EventMachine framework after successfully attaching
+      # to $stdin.
+      #
+      # Adds signal handlers and calls the #setup_dataflow method.
+      def post_init      
+        self.class.add_signal_traps
+        setup_dataflow
+      end
+      
+      #
+      # == Reading Input == 
+      #
+      
+      # Called by EventMachine framework after successfully reading a
+      # line from $stdin.
+      #
+      # @param [String] line
+      def receive_line line
+        send_through_dataflow(line)
+      rescue => e
+        error = Wukong::Error.new(e)
+        # EM.stop
+        
+        # We'd like to *raise* `error` here and have it be handled by
+        # Wukong::Runner.run but we are fighting with EventMachine.run
+        # which executes in the middle.
+        #
+        # It seems no matter what we do, EventMachine.run will swallow
+        # any Exception raised here (including SystemExit) and exit
+        # the Ruby process with a return code of 0.
+        #
+        # Instead we just log the message that *would* have gotten
+        # logged by Wukong::Runner.run and leave it to EventMachine to
+        # exit very unnaturally.
+        log.error(error.message)
+      end
+
+      #
+      # == Handling Output == 
+      #
+      
+      # Writes a record to $stdout.
+      #
+      # @param [#to_s] record
+      def process(record)
+        $stdout.puts record
+      end
+
+      #
+      # == Shutdown == 
+      #
+
+      # Called by EventMachine framework after EOF from $stdin.
+      #
+      # Calls #finalize_and_stop_dataflow method and stops the
+      # EventMachine reactor.
+      def unbind
+        finalize_and_stop_dataflow
+        EM.stop
+      end
+    end
+  end
+end

data/lib/wukong/logger.rb

@@ -0,0 +1,102 @@
+module Wukong
+
+  class LogFactory
+
+    attr_reader :created_log
+
+    def self.default_outputter klass
+      Log4r::StderrOutputter.new('console', formatter: default_formatter(klass))
+    end
+
+    def self.default_formatter klass
+      Log4r::PatternFormatter.new(pattern: default_pattern(klass))
+    end
+
+    def self.default_pattern klass
+      "%l %d [%-20c] -- %m"
+    end
+
+    def self.configure(klass, options = {})
+      factory = new(klass, options)
+      factory.created_log
+    end
+
+    def initialize(logger, config)
+      @created_log = logger.is_a?(Log4r::Logger) ? logger : Log4r::Logger.new(logger.to_s)
+      outputter(LogFactory.default_outputter(logger)) unless ancestry_has_outputter?(@created_log)
+      apply_options(config)
+    end
+
+    def ancestry_has_outputter? lgr
+      if lgr.respond_to?(:outputters) && !lgr.outputters.empty?
+        true
+      elsif lgr.respond_to?(:parent) && !lgr.parent.nil?
+        ancestry_has_outputter? lgr.parent
+      else
+        false        
+      end
+    end
+     
+    def apply_options config
+      config.each_pair do |option, value| 
+        begin
+          send(option, value)
+        rescue
+          raise Error.new("Error setting option <#{option}> to value <#{value}>")
+        end
+      end
+    end
+
+    def outputter outptr
+      created_log.outputters = outptr
+    end
+
+    def level lvl
+      created_log.level = lookup_level(lvl.to_sym)
+    end
+
+    def lookup_level lvl
+      { 
+        debug: Log4r::DEBUG,
+        info:  Log4r::INFO,
+        warn:  Log4r::WARN
+      }.fetch(lvl){ raise Error.new("Invalid log level: <#{lvl}>") }
+    end
+
+    def pattern ptrn
+      created_log.outputters.each do |output|
+        keep_date_format = output.formatter.date_pattern
+        output.formatter = Log4r::PatternFormatter.new(pattern: ptrn, date_format: keep_date_format)
+      end
+    end
+
+    def date_format fmt
+      created_log.outputters.each do |output|
+        keep_pattern = output.formatter.pattern
+        output.formatter = Log4r::PatternFormatter.new(pattern: keep_pattern, date_format: fmt)
+      end
+    end    
+  end
+
+  # Mixin for logging behavior
+  module Logging
+
+    def self.included klass
+      if klass.ancestors.include?(Gorillib::Model)
+        klass.class_eval do
+          field(:log, Whatever, :default => ->{ Wukong::LogFactory.configure(self.class) }, :doc => "Shared Wukong logger")
+
+          def receive_log params
+            @log = LogFactory.configure(self.class, params)
+          end
+        end
+      else
+        klass.class_attribute :log
+        klass.log = LogFactory.configure(klass)
+      end
+    end    
+  end
+  
+  # Default log. Parent to all logs created in Wukong namespace
+  Log = LogFactory.configure(Wukong)
+end

data/lib/wukong/model/faker.rb

@@ -0,0 +1,136 @@
+require 'forgery'
+require 'uuidtools'
+
+# Bolt extra parameters onto field declaration
+
+class Gorillib::Model::Field
+  field :faker,      Whatever, :doc => "Factory for creating a fake value; anything responding to #fake_value()", :tester => true
+  field :faker_args, Array,    :doc => "Parameters to splat in for calls to the faker factory", :default => []
+
+  def fake_value
+    faker = read_attribute(:faker)
+    case faker
+    when nil          then self.type.fake_value(*faker_args)
+    when Symbol       then Wukong::Faker::Helpers.public_send(faker, *faker_args)
+    when Proc, Method then faker.call(*faker_args)
+    else                   faker.fake_value(*faker_args)
+    end
+  end
+end
+
+module Wukong
+  #
+  # @example
+  #
+  #   class Person
+  #     include Gorillib::Model
+  #     include Wukong::Faker
+  #     field :first_name, String, :faker => ->{ %w[John Paul George Ringo] }
+  #     field :last_name,  String
+  #     field :user_id,    String, :faker => :fake_identifier
+  #
+  module Faker
+    extend Gorillib::Concern
+
+    module ClassMethods
+
+      def fake_value
+        new.update_attributes(fake_attrs)
+      end
+
+    protected
+      #
+      # For the example of a field `:foo` of type `HappyType`, calls the first of:
+      # * the instance method :fake_foo if it exists.
+      # * `fake_value` on the `:faker => XX` parameter in `:foo`'s field definition.
+      # * `fake_value` on the field's type
+      #
+      # If the faker is simple, or if there's a standard faker for what you want,
+      # When a generic faker won't do, or is complicated, use
+      def fake_attrs
+        attrs = {}
+        fields.each do |field_name, field|
+          attrs[field_name] = self.respond_to?("fake_#{field_name}") ? send("fake_#{field_name}") : field.fake_value
+        end
+        attrs
+      end
+
+      # defines a method to return an arbitrary value from the given list.
+      def fake_from_list(field_name, values)
+        define_singleton_method("fake_#{field_name}"){ values.sample }
+      end
+    end
+
+    module Helpers
+      extend self
+
+      def fake_integer(opts={})
+        opts = { :min => 0, :max => 1 }.merge(opts)
+        min, max = [ opts[:min].to_i, opts[:max].to_i ].sort
+        return min if min == max
+        min + Kernel.rand(max-min)
+      end
+      def fake_float(opts={})
+        opts = { :min => 0.0, :max => 1.0 }.merge(opts)
+        min, max = [ opts[:min].to_f, opts[:max].to_f ].sort
+        min + ((max-min) * Kernel.rand)
+      end
+
+      #  A latitude unif. dist from San Diego  lat 32 lng -117 to Maine lat 44 lng -68 -- sorry non-yanks
+      def fake_latitude(opts={})  ; fake_float({:min =>   32.0, :max =>  45.0}.merge(opts)) ; end
+      #  A longitude unif. dist from San Diego lat 32 lng -117 to Maine lat 44 lng -68 -- sorry non-yanks
+      def fake_longitude(opts={}) ; fake_float({:min => -117.0, :max => -68.0}.merge(opts)) ; end
+
+      def fake_country_id()       ; Forgery::Internet.cctld ; end       # KLUDGE: uses tlds, not country codes
+      def fake_area_code()        ; fake_integer(:min => 200, :max => 987) ; end
+
+      def fake_word()             ; Forgery::LoremIpsum.word(:random => true) ; end
+      def fake_identifier()       ; fake_word.downcase.gsub(/\W/,'_').gsub(/^[^a-z]/, 'a') ; end
+      def fake_sentence()         ; Forgery::LoremIpsum.sentence(:random => true) ; end
+      def fake_paragraph()        ; Forgery::LoremIpsum.paragraph(:random => true) ; end
+
+      def fake_fileext()          ; %w[ rb html py sh com bat doc txt pdf xml exe app].sample ; end
+      def fake_basename()         ; "#{fake_identifier}.#{fake_fileext}" ; end
+      def fake_dirname()          ; File.join('/', * 3.times.map{ fake_identifier }) ; end
+      def fake_filename()         ; File.join(fake_dirname, fake_basename) ; end
+
+      def fake_hostname()         ; Forgery::Internet.domain_name ; end
+      def fake_ip_addresss()      ; Forgery::Internet.ip_v4       ; end
+      def fake_version_number()   ; "%.1f" % fake_float(:min => 0.2, :max => 9.4) ; end
+
+    end
+  end
+end
+
+module Gorillib::Factory
+  class BaseFactory
+    def fake_value(opts={})
+      if not @faker_warned then warn "No faker for #{self}" ; @faker_warned = true ; end
+      nil
+    end
+  end
+
+  StringFactory.class_eval   { def fake_value()        receive(Wukong::Faker::Helpers.fake_word)          ; end }
+  GuidFactory.class_eval     { def fake_value()        receive(UUIDTools::UUID.random_create.to_s)        ; end }
+  HostnameFactory.class_eval { def fake_value()        receive(Wukong::Faker::Helpers.fake_hostname)      ; end }
+  IpAddressFactory.class_eval{ def fake_value()        receive(Wukong::Faker::Helpers.fake_ip_addresss)   ; end }
+
+  SymbolFactory.class_eval   { def fake_value()        receive(Wukong::Faker::Helpers.fake_identifier)    ; end }
+  PathnameFactory.class_eval { def fake_value()        receive(Wukong::Faker::Helpers.fake_filename)      ; end }
+
+  IntegerFactory.class_eval  { def fake_value(opts={}) receive(Wukong::Faker::Helpers.fake_integer(opts)) ; end }
+  BignumFactory.class_eval   { def fake_value(opts={}) super({:min => 2**68, :max => 2**90}.merge(opts))  ; end }
+
+  FloatFactory.class_eval    { def fake_value(opts={}) receive(Wukong::Faker::Helpers.fake_float(opts))   ; end }
+  ComplexFactory.class_eval  { def fake_value()        receive(Kernel.rand, Kernel.rand)                  ; end }
+  RationalFactory.class_eval { def fake_value()        receive(Kernel.rand.to_r)                          ; end }
+
+  TimeFactory.class_eval     { def fake_value()        receive(Time.now)                                  ; end }
+
+  ExceptionFactory.class_eval{ def fake_value()        Exception.constants.sample                         ; end }
+
+  NilFactory.class_eval      { def fake_value()        nil                                                ; end }
+  TrueFactory.class_eval     { def fake_value()        true                                               ; end }
+  FalseFactory.class_eval    { def fake_value()        false                                              ; end }
+  BooleanFactory.class_eval  { def fake_value()        [true, false].sample                               ; end }
+end

data/lib/wukong/model/flatpack_parser/flat.rb

@@ -0,0 +1,60 @@
+class String
+  def match_all regex
+    self.to_enum(:scan, regex).map {Regexp.last_match}
+  end
+end 
+
+module Wukong
+  module FlatPack
+
+    # Creates a 'simple' token from the supplied string
+    # and position.
+    def self.simple_token_from_string(str, position)
+      token_pieces = str.match(Language::NAMED_SIMPLE_TYPE_RE)
+      t = Flat::Tokens.token_for_indicator(token_pieces[:type])
+      t.position = position
+      t.length = token_pieces[:length].nil? ? nil : token_pieces[:length].to_i
+      t.modifier = token_pieces[:modifier]
+      return t
+    end
+
+    # Creates a fixed point token. Strict input formatting is
+    # enforced if the strict param is true.
+    def self.fixed_point_token_from_string(str, position, strict=true)
+      float_pieces = str.match(Language::NAMED_FIXED_POINT_RE)
+      t = Flat::Tokens::FixedPointToken.new
+      t.position = position
+      t.strict = strict
+      t.power = float_pieces[:power].nil? ? nil : float_pieces[:power].to_i
+      t.length = float_pieces[:length].to_i
+      return t
+    end
+
+    # Validates the supplied format string
+    # and creates a parser from it.
+    def self.create_parser(str, delimiter_width=0, strict_fixed_point=true)
+      return nil unless Language.string_in_lang str
+      lang = []
+      str.match_all(Language::CAPTURE_TOKEN_RE).each do |match|
+        token_str = match[0]
+        case token_str
+        when Language::TOTAL_SIMPLE_TYPE_RE
+          lang << simple_token_from_string(token_str, match.begin(0))
+        when Language::TOTAL_FIXED_POINT_RE
+          lang << fixed_point_token_from_string(token_str, match.begin(0), strict_fixed_point)
+        when Language::TOTAL_DATE_RE
+          date_match = token_str.match(Language::NAMED_DATE_RE)
+          #TODO: Implement
+        end
+        if delimiter_width != 0
+          t = Flat::Tokens::IgnoreToken.new
+          t.position = -1
+          t.length = delimiter_width
+          lang << t
+        end
+      end
+      lang = lang[0..-2] if delimiter_width != 0 #pop off the delimiter on the end
+      return Flat::Parser.new(lang)
+    end
+  end
+end

data/lib/wukong/model/flatpack_parser/flatpack.rb

@@ -0,0 +1,4 @@
+require 'flat'
+require 'lang'
+require 'parser'
+require 'tokens'

data/lib/wukong/model/flatpack_parser/lang.rb

@@ -0,0 +1,46 @@
+module Wukong
+  module FlatPack
+    module Language
+      
+      #language definition
+      SIMPLE_TYPES = %w{i f s b _}
+      SIMPLE_TYPE_RE = "[#{SIMPLE_TYPES.join}]"
+
+      MODIFIERS = %w{+ *}
+      MODIFIER_RE = "[#{MODIFIERS.join}]"
+
+      SIMPLE_TOKEN_RE = "#{SIMPLE_TYPE_RE}(?:#{MODIFIER_RE}|[0-9]+)?"
+
+      DATE_TYPES = %w{a A b B c d H I j m M p S U w W x X Y Z}
+      DATE_TYPES_RE = "[#{DATE_TYPES.join} ]" # the extra space is supposed to be there
+      DATE_TOKEN_RE = "%#{DATE_TYPES_RE}*%" 
+
+      FIXED_POINT_TYPE = 'D'
+      FIXED_POINT_SEP = 'e'
+      FIXED_POINT_TOKEN_RE = "#{FIXED_POINT_TYPE}\\d+(?:#{FIXED_POINT_SEP}\\d+)?"
+
+      TOKENS = [SIMPLE_TOKEN_RE, DATE_TOKEN_RE, FIXED_POINT_TOKEN_RE]
+      TOKEN_RE =  "#{TOKENS.join('|')}"
+      CAPTURE_TOKEN_RE =  /(#{TOKENS.join('|')})/
+
+      LANGUAGE_RE = /^(?:(#{TOKEN_RE}) *)+$/
+
+      #total regexes, i.e. regexes that must match the whole string
+      TOTAL_SIMPLE_TYPE_RE = /^#{SIMPLE_TOKEN_RE}$/
+      TOTAL_FIXED_POINT_RE = /^#{FIXED_POINT_TOKEN_RE}$/
+      TOTAL_DATE_RE = /^#{DATE_TOKEN_RE}$/
+
+      #named regexes used for parsing tokens
+      NAMED_SIMPLE_TYPE_RE = /(?<type>#{SIMPLE_TYPE_RE})(?:(?<length>[0-9]+)|(?<modifier>#{MODIFIER_RE}))?/
+      NAMED_FIXED_POINT_RE = /#{FIXED_POINT_TYPE}(?<length>\d+)(?:#{FIXED_POINT_SEP}(?<power>\d+))?/
+      NAMED_DATE_RE = /%(?<format>#{DATE_TYPES_RE})%/
+
+      # Returns true if the supplied string is in
+      # Flat's formatting language, as determined
+      # by the LANGUAGE_RE regex.
+      def self.string_in_lang(str)
+        return (not (str =~ LANGUAGE_RE).nil?)
+      end
+    end
+  end
+end