wukong 3.0.0.pre → 3.0.0.pre2

data/old/wukong/extensions/hash_keys.rb

@@ -1,16 +0,0 @@
-class Hash
-
-  # Return a new hash with all keys converted to symbols.
-  def symbolize_keys
-    inject({}) do |options, (key, value)|
-      options[(key.to_sym rescue key) || key] = value
-      options
-    end
-  end
-
-  # Destructively convert all keys to symbols.
-  def symbolize_keys!
-    self.replace(self.symbolize_keys)
-  end
-
-end

data/old/wukong/extensions/hash_like.rb

@@ -1,150 +0,0 @@
-module Wukong
-  #
-  # A hashlike has to
-  #
-  # *
-  # * The arguments to your initializer should be the same as the keys, in order
-  #   If not, you must override #from_hash
-  #
-  #
-  module HashLike
-
-    # List of possible keys --
-    # delegates to the class
-    def keys
-      self.class.keys
-    end
-
-    #
-    # Return a Hash containing only values for the given keys.
-    #
-    # Since this is intended to mirror Hash#slice it will harmlessly ignore keys
-    # not present in the struct.  They will be unset (hsh.include? is not true)
-    # as opposed to nil.
-    #
-    def slice *keys
-      keys.inject({}) do |hsh, key|
-        hsh[key] = send(key) if respond_to?(key)
-        hsh
-      end
-    end
-
-    #
-    # values_at like a hash
-    #
-    # Since this is intended to mirror Hash#values_at it will harmlessly ignore
-    # keys not present in the struct
-    #
-    def values_of *keys
-      keys.map{|key| self.send(key) if respond_to?(key) }
-    end
-
-    #
-    # Convert to a hash
-    #
-    def to_hash
-      slice(*self.class.members)
-    end
-
-    #
-    # Analagous to Hash#each_pair
-    #
-    def pairs
-      self.class.members.map{|attr| [attr, self[attr]] }
-    end
-
-    #
-    # Analagous to Hash#each_pair
-    #
-    def each_pair *args, &block
-      pairs.each(*args, &block)
-    end
-
-    #
-    # Analagous to Hash#merge
-    #
-    def merge *args
-      self.dup.merge!(*args)
-    end
-    def merge! hsh, &block
-      raise "can't handle block arg yet" if block
-      hsh.each_pair{|key, val| self.send("#{key}=", val) if self.respond_to?("#{key}=") }
-      self
-    end
-    alias_method :update, :merge!
-
-    #
-    # Merge hashes recursively.
-    # Nothing special happens to array values
-    #
-    #     x = { :subhash => { 1 => :val_from_x, 222 => :only_in_x, 333 => :only_in_x }, :scalar => :scalar_from_x}
-    #     y = { :subhash => { 1 => :val_from_y, 999 => :only_in_y },                    :scalar => :scalar_from_y }
-    #     x.deep_merge y
-    #     => {:subhash=>{1=>:val_from_y, 222=>:only_in_x, 333=>:only_in_x, 999=>:only_in_y}, :scalar=>:scalar_from_y}
-    #     y.deep_merge x
-    #     => {:subhash=>{1=>:val_from_x, 222=>:only_in_x, 333=>:only_in_x, 999=>:only_in_y}, :scalar=>:scalar_from_x}
-    #
-    def deep_merge hsh2
-      merge hsh2, &Hash::DEEP_MERGER
-    end
-
-    #
-    # remove all key-value pairs where the value is blank
-    #
-    def compact_blank
-      to_hash.compact_blank!
-    end
-
-    module ClassMethods
-      #
-      # Instantiate an instance of the struct from a hash
-      #
-      # Specify has_symbol_keys if the supplied hash's keys are symbolic;
-      # otherwise they must be uniformly strings
-      #
-      def from_hash(hsh, has_symbol_keys=false)
-        extract_keys = has_symbol_keys ? self.keys.map(&:to_sym) : self.keys.map(&:to_s)
-        self.new(*hsh.values_of(*extract_keys))
-      end
-      #
-      # The last portion of the class in underscored form
-      # memoized
-      #
-      def resource_name
-        @resource_name ||= self.class_basename.underscore.to_sym
-      end
-      # The last portion of the class name
-      # memoized
-      #
-      # @example
-      #   This::That::TheOther.new.class_basename   # => TheOther
-      def class_basename
-        @class_basename ||= self.to_s.gsub(%r{.*::}, '')
-      end
-    end
-
-    def self.included base
-      base.class_eval do
-        extend ClassMethods
-      end
-    end
-
-    def coerce_attr attr, coerce_blank_to_nil=false, &block
-      orig_val = self.send(attr)
-      new_val = (coerce_blank_to_nil && orig_val.blank?) ? nil : block.call(orig_val)
-      self.send("#{attr}=", new_val)
-    end
-
-    def coerce_to_int! attr, *args
-      coerce_attr(attr, *args) do |val|
-        val.to_i
-      end
-    end
-
-    def coerce_to_date! attr, *args
-      coerce_attr(attr, *args){|val| val.is_a?(DateTime) ? val : DateTime.parse(val) rescue nil }
-    end
-
-  end
-
-end

data/old/wukong/extensions/hashlike_class.rb

@@ -1,47 +0,0 @@
-require 'wukong/extensions/class'
-module Wukong
-
-  module HashlikeClass
-    module ClassMethods
-      def has_members *members
-        self.members ||= []
-        self.members = members.map(&:to_s) + self.members
-        self.members.each do |member|
-          attr_accessor member.to_sym
-        end
-      end
-      alias_method :has_member, :has_members
-      def keys
-        members
-      end
-    end
-
-    def [](key)
-      self.send(key)
-    end
-
-    def []=(key, val)
-      self.send("#{key}=", val)
-    end
-
-    def to_a
-      values_of(*members)
-    end
-
-    def to_flat
-      to_a.map(&:to_flat).flatten
-    end
-
-    def self.included base
-      base.class_eval do
-        extend ClassMethods
-        include HashLike
-        class_inheritable_accessor :members
-
-        def to_hash *args
-          super(*args).merge 'type' => self.class.to_s
-        end
-      end
-    end
-  end
-end

data/old/wukong/extensions/module.rb

@@ -1,2 +0,0 @@
-require 'extlib/object'
-require 'extlib/module'

data/old/wukong/extensions/pathname.rb

@@ -1,27 +0,0 @@
-require 'pathname'
-class Pathname
-  # Append path segments and expand to absolute path
-  #
-  #   file = Pathname(Dir.pwd) / "subdir1" / :subdir2 / "filename.ext"
-  #
-  # @param [Pathname, String, #to_s] path path segment to concatenate with receiver
-  #
-  # @return [Pathname]
-  #   receiver with _path_ appended and expanded to an absolute path
-  #
-  # @api public
-  def /(path)
-    (self + path).expand_path
-  end
-
-  def self.[](*vals)
-    new( File.join(vals) )
-  end
-end
-
-class Subdir < Pathname
-  def self.[](*vals)
-    dir = File.dirname(vals.shift)
-    new(File.join(dir, *vals))
-  end
-end

data/old/wukong/extensions/string.rb

@@ -1,65 +0,0 @@
-#
-# String Monkeypatched for processing with wukong: see wukong/extensions/string
-#
-String.class_eval do
-  # By default, +camelize+ converts strings to UpperCamelCase. If the argument to +camelize+
-  # is set to <tt>:lower</tt> then +camelize+ produces lowerCamelCase.
-  #
-  # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
-  #
-  # Examples:
-  #   "active_record".camelize                # => "ActiveRecord"
-  #   "active_record".camelize(:lower)        # => "activeRecord"
-  #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
-  #   "active_record/errors".camelize(:lower) # => "activeRecord::Errors"
-  def camelize(first_letter_in_uppercase = true)
-    if first_letter_in_uppercase
-      self.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-    else
-      self.first + camelize(self)[1..-1]
-    end
-  end
-
-  #
-  # The reverse of +camelize+. Makes an underscored, lowercase form from the expression in the string.
-  #
-  # Changes '::' to '/' to convert namespaces to paths.
-  #
-  # Examples:
-  #   "ActiveRecord".underscore         # => "active_record"
-  #   "ActiveRecord::Errors".underscore # => active_record/errors
-  #
-  # Stolen from active_support
-  #
-  def underscore
-    gsub(/::/, '/').
-      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-      gsub(/([a-z\d])([A-Z])/,'\1_\2').
-      tr("-", "_").
-      downcase
-  end
-
-  # Tries to find a constant with the name specified in the argument string:
-  #
-  #   "Module".constantize     # => Module
-  #   "Test::Unit".constantize # => Test::Unit
-  #
-  # The name is assumed to be the one of a top-level constant, no matter whether
-  # it starts with "::" or not. No lexical context is taken into account:
-  #
-  #   C = 'outside'
-  #   module M
-  #     C = 'inside'
-  #     C               # => 'inside'
-  #     "C".constantize # => 'outside', same as ::C
-  #   end
-  #
-  # NameError is raised when the name is not in CamelCase or the constant is
-  # unknown.
-  def constantize
-    unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ self
-      raise NameError, "#{self.inspect} is not a valid constant name!"
-    end
-    Object.module_eval("::#{$1}", __FILE__, __LINE__)
-  end
-end

data/old/wukong/extensions/struct.rb

@@ -1,17 +0,0 @@
-require 'wukong/extensions/hash'
-require 'wukong/extensions/hash_like'
-require 'wukong/extensions/symbol'
-
-#
-# extensions/struct
-#
-# Add several methods to make a struct duck-type much more like a Hash
-#
-Struct.class_eval do
-  include Wukong::HashLike
-  def self.keys
-    members
-  end
-end
-
-

data/old/wukong/extensions/symbol.rb

@@ -1,11 +0,0 @@
-#
-# h2. extensions/symbol.rb -- extensions to symbol class
-#
-class Symbol
-  #
-  # Turn the symbol into a simple proc (stolen from
-  # <tt>ActiveSupport::CoreExtensions::Symbol</tt>).
-  def to_proc
-    Proc.new { |*args| args.shift.__send__(self, *args) }
-  end unless method_defined?(:to_proc)
-end

data/old/wukong/filename_pattern.rb

@@ -1,74 +0,0 @@
-module Wukong
-    class FilenamePattern
-      # the filename pattern, e.g. 'ripd/:handle/:date/:handle+:timestamp-:pid-:hostname.tsv'
-      attr_accessor :pattern
-      # custom token replacements
-      attr_accessor :token_val_defaults
-
-      DEFAULT_PATTERN_STR = ":dest_dir/:handle_prefix/:handle/:date/:handle:timestamp-:pid-:hostname.tsv"
-
-      def initialize pattern, token_val_defaults={}
-        self.pattern = pattern
-        self.token_val_defaults    = token_val_defaults
-      end
-
-      #
-      # walk through pattern, replacing tokens (eg :time or :pid) with the
-      # corresponding value.
-      #
-      # Don't use ':' in a pattern except to introduce a token
-      # and separate tokens with '-', '+' '/' or '.'
-      #
-      def make token_vals={}
-        token_vals = token_val_defaults.merge token_vals
-        token_vals[:timestamp] ||= Time.now.utc.strftime("%Y%m%d%H%M%S")
-        val = pattern.gsub(/:(\w+)/){ replace($1, token_vals)  }
-        val
-      end
-
-      def to_s token_vals={}
-        make token_vals
-      end
-
-      #
-      # substitute for token
-      #
-      def replace token, token_vals
-        token = token.to_sym
-        return token_vals[token] if token_vals.include? token
-        case token
-        when :pid           then pid
-        when :hostname      then hostname
-        when :handle        then token_vals[:handle]
-        when :handle_prefix then token_vals[:handle].to_s[0..5]
-        when :timestamp     then token_vals[:timestamp]
-        when :date          then token_vals[:timestamp][ 0..7]
-        when :time          then token_vals[:timestamp][ 8..13]
-        when :hour          then token_vals[:timestamp][ 8..9]
-        when :h4            then "%0.2d" % (( token_vals[:timestamp][8..9].to_i / 4 ) * 4)
-        when :min           then token_vals[:timestamp][10..11]
-        when :sec           then token_vals[:timestamp][12..13]
-        when :s10           then "%0.2d" % (( token_vals[:timestamp][12..13].to_i / 10 ) * 10)
-        else
-          raise "Don't know how to encode token #{token} #{token_vals[token]}"
-        end
-      end
-
-      # Memoized: the hostname for the machine running this script.
-      def hostname
-        @hostname ||= ENV['HOSTNAME'] || `hostname`.chomp
-      end
-      # Memoized: the Process ID for this invocation.
-      def pid
-        @pid      ||= Process.pid
-      end
-
-      # Characters deemed safe in a filename;
-      SAFE_CHARS = 'a-zA-Z0-9_\-\.\+\/'
-      RE_SAFE_FILENAME = %r{[^#{SAFE_CHARS}]+}moxi
-      def self.sanitize str
-        str.gsub(RE_SAFE_FILENAME, '-')
-      end
-
-    end
-end

data/old/wukong/helper.rb

@@ -1,7 +0,0 @@
-module Wukong
-  module Helper
-
-    autoload :Tokenize, 'wukong/helper/tokenize'
-    
-  end
-end

data/old/wukong/helper/stopwords.rb

@@ -1,195 +0,0 @@
-module Wukong
-  module Corpus
-    STOPWORDS = %w[
-        the
-        of
-        and
-        a
-        in
-        to
-        it
-        is
-        was
-        I
-        for
-        that
-        you
-        he
-        be
-        with
-        on
-        by
-        at
-        have
-        are
-        not
-        this
-        but
-        had
-        they
-        his
-        from
-        she
-        which
-        or
-        we
-        an
-        were
-        as
-        do
-        been
-        their
-        has
-        would
-        there
-        what
-        will
-        all
-        if
-        can
-        her
-        said
-        who
-        so
-        up
-        them
-        when
-        some
-        could
-        him
-        into
-        its
-        then
-        out
-        my
-        about
-        did
-        your
-        me
-        other
-        just
-        more
-        these
-        also
-        any
-        see
-        very
-        may
-        well
-        should
-        than
-        how
-        get
-        way
-        our
-        made
-        got
-        after
-        many
-        those
-        go
-        being
-        because
-        down
-        such
-        over
-        must
-        still
-        even
-        too
-        here
-        come
-        own
-        last
-        does
-        oh
-        no
-        where
-        us
-        same
-        might
-        yes
-        put
-        another
-        most
-        again
-        under
-        much
-        why
-        each
-        while
-        off
-        went
-        used
-        without
-        give
-        within
-
-        am
-        aren't
-        between
-        both
-        can't
-        cannot
-        couldn't
-        didn't
-        doesn't
-        doing
-        don't
-        hadn't
-        hasn't
-        haven't
-        having
-        he'd
-        he'll
-        he's
-        here's
-        hers
-        how's
-        i'd
-        i'll
-        i'm
-        i've
-        isn't
-        it'd
-        it'll
-        it's
-        let's
-        once
-        only
-        ought
-        ours
-        she'd
-        she'll
-        she's
-        shouldn't
-        that's
-        theirs
-        there's
-        they'd
-        they'll
-        they're
-        they've
-        through
-        wasn't
-        we'd
-        we'll
-        we're
-        we've
-        weren't
-        what's
-        where's
-        who's
-        won't
-        wouldn't
-        you'd
-        you'll
-        you're
-        you've
-        yours
-
-    ].to_set
-    STOPWORDS_3 = STOPWORDS.reject{|w| w.length < 3 }.to_set
-
-  end
-end