cabbage 0.1.3 → 0.2.0

data/README.rdoc

@@ -1,10 +1,11 @@
 = cabbage
 
-Cabbage is a simple gem that parses Graphviz DOT files.
+Cabbage is a simple library of parsers. Currently, it parses Graphviz DOT files and emails. The goal is maximum ease of use and simplicity.
 
 use:
-install the gem named 'cabbage', and parse a dotfile by invoking 'Cabbage.dotfile(arg)' in your script.
-(where 'arg' is either a string containing either the path to a dotfile or a dot-formatted string)
+install the gem named 'cabbage', and parse a dotfile by invoking 'Cabbage.dotfile("dotfile")' in your script.
+(where "dorfile" is either a string containing either the path to a dotfile or a dot-formatted string)
+Similarly, Cabbage.email("email_file") will parse an email. More parsers to come as I have need of them.
 
 == Contributing to cabbage
 Send me a message if you feel the urge to contribute.

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.2.0

data/cabbage.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "cabbage"
-  s.version = "0.1.3"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Josh Lauer"]
-  s.date = "2011-09-24"
+  s.date = "2011-09-26"
   s.description = "More to come."
   s.email = "josh.lauer75@gmail.com"
   s.extra_rdoc_files = [
@@ -26,6 +26,11 @@ Gem::Specification.new do |s|
     "VERSION",
     "cabbage.gemspec",
     "lib/cabbage.rb",
+    "lib/cabbage/dotfile/parser.rb",
+    "lib/cabbage/email/email.rb",
+    "lib/cabbage/email/mime_part.rb",
+    "lib/cabbage/email/parser.rb",
+    "lib/cabbage/string_extras.rb",
     "test/helper.rb",
     "test/test_cabbage.rb"
   ]

data/lib/cabbage.rb

@@ -1,138 +1,22 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
 module Cabbage
 
-  # just pass calls to new on to DotFile class for now
-  def self.new(*args, &block)
-    DotFile.new(args[0], &block) # passes the the first argument on
-  end
+  # # You can't instantiate a cabbage. (yet)
+  # def self.new(*args, &block)
+  #
+  # end
 
+  # graphviz DOT format files
   def self.dotfile(*args, &block)
+	  require_relative "cabbage/dotfile/parser" 
     DotFile.new(args[0], &block) # passes the the first argument on
   end
 
-  class DotFile
-   
-    # pass it a string containing either the DotFile itself, or the path to
-    # a DOTfile.
-    def initialize(source = nil)
-      @raw_dotfile = ""  # unparsed DOTfile
-      @graph_type = ""   # 
-      @title = ""
-      @header = {}
-      @nodes = []
-      @connections = []
-      source != nil if parse(source)
-    end
-
-    attr_accessor :raw_dotfile, :graph_type, :title, :header, :nodes, :connections
-
-    # no public methods yet apart from accessors
-
-    # parsing methods below
-    private
-
-    def load_from_file(dotfile_path)
-      @raw_dotfile = IO.read(dotfile_path)
-    end
-
-    def load_from_string(dotfile)
-      @raw_dotfile = dotfile
-    end
-
-    def parse(source = nil)
-      begin
-        if source.class == String
-          if source.include?("\n")
-            load_from_string(source)
-          else
-            load_from_file(source)
-          end
-          parse_dotfile()
-        elsif source
-          raise
-        end
-      rescue
-        puts 'Unhandled parser exception! Parse failed.'
-      end
-    end 
-
-    # a dotfile has four components:
-    # graph_type, header, nodes, connections
-    def parse_dotfile
-      # the chunk is everything inside '{}'
-      raw_chunk = @raw_dotfile.split("{")[1].split("}")[0].strip
-      # pull out the header
-      raw_header = raw_chunk.match(/([\w\s*=".,\s\[\]_\\]+;)*/m)[0]
-      # find body by chopping header off chunk
-      raw_body = raw_chunk.sub(raw_header, "")
-      # split the body on '>];', which delimits the tables section
-      raw_connections = raw_body.split(">];")[-1].strip
-      # split out the tables section from the body
-      raw_tables = raw_body.split(">];")[0 .. -2].join(">];").strip + " \n>];"
-
-      # assemble the output hash
-      @graph_type = @raw_dotfile.match(/\A\s*((?:di)?graph)/)[1]
-      @title = @raw_dotfile.match(/\A\s*(?:di)?graph\s*(\w+)/)[1]
-      @header = parse_header(raw_header, ";")
-      @nodes = parse_nodes(raw_tables)
-      @connections = parse_connections(raw_connections)
-    end
-
-    def parse_header(raw_header, delimiter)
-      temp = {}
-      raw_header.scan(/(\w+)(?:\s*=?\s*)(?:["|\[](.+?)["|\]]#{delimiter})/m).each do |n|
-        if n[1].include?("=")
-          temp[n[0]] = parse_header(n[1], ",")
-        else
-          temp[n[0]] = n[1].strip
-        end
-      end
-      return temp
-    end
-
-    def chop_tables(raw_tables)
-      {}.tap do |output|
-        raw_tables.scan(/\s*\"*([\w:]+)\"*\s*\[\w+\s*=\s*<(.+?)>\];/m).each do |n|
-          output[ n[0].gsub('\"', '').strip ] = n[1].strip
-        end
-      end
-    end
-
-    def parse_nodes(raw_tables)
-      result = []
-      chop_tables(raw_tables).each do |name, table|
-        node = {:name => name.sub("m_", "")}
-        node[:fields] = []
-        if table.include?("|")
-          table.split("|")[1].scan(/port="([\w:]+)">[^<]+<[^>]+>(.+?)</m).each do |pair|
-            node[:fields] << { :name => pair[0], :type => pair[1] }
-          end
-        end
-        result << node
-      end
-      result
-    end
-
-    def parse_connections(node_chunk)
-      output = []
-      node_chunk.split("\n").each do |this_line|
-        this_connection = {}
-        temp = this_line.split("->")
-        this_connection[:start_node] = temp[0].gsub('"', '').gsub('\\', '').sub('m_', '').strip
-        this_connection[:end_node] = temp[1].split("[")[0].gsub('"', '').gsub('\\', '').sub('m_', '').strip
-        tokens = temp[1].split("[")[1].split("]")[0].split(",")
-        tokens.each do |token_string|
-          token_pair = token_string.split("=")
-          this_connection[token_pair[0].strip.gsub('"', '').gsub('\\', '').to_sym] = token_pair[1].strip.gsub('"', '').gsub('\\', '')
-        end
-        output << this_connection
-      end
-      return output
-    end
-
-
+  # raw emails
+  def self.email(*args, &block)
+	  require_relative "cabbage/email/email"
+    require_relative "cabbage/email/parser"
+    require_relative "cabbage/string_extras"
+    Email.new(args[0], &block)
   end
 
-end
-
+end

data/lib/cabbage/dotfile/parser.rb

@@ -0,0 +1,125 @@
+# encoding: UTF-8
+module Cabbage
+
+  class DotFile
+   
+    # pass it a string containing either the DotFile itself, or the path to
+    # a DOTfile.
+    def initialize(source = nil)
+      @raw_dotfile = ""  # unparsed DOTfile
+      @graph_type = ""   # 
+      @title = ""
+      @header = {}
+      @nodes = []
+      @connections = []
+      source != nil if parse(source)
+    end
+
+    attr_accessor :raw_dotfile, :graph_type, :title, :header, :nodes, :connections
+
+    # no public methods yet apart from accessors
+
+    # parsing methods below
+    private
+
+    def load_from_file(dotfile_path)
+      @raw_dotfile = IO.read(dotfile_path)
+    end
+
+    def load_from_string(dotfile)
+      @raw_dotfile = dotfile
+    end
+
+    def parse(source = nil)
+      begin
+        if source.class == String
+          if source.include?("\n")
+            load_from_string(source)
+          else
+            load_from_file(source)
+          end
+          parse_dotfile()
+        elsif source
+          raise
+        end
+      rescue
+        puts 'Unhandled parser exception! Parse failed.'
+      end
+    end 
+
+    # a dotfile has four components:
+    # graph_type, header, nodes, connections
+    def parse_dotfile
+      # the chunk is everything inside '{}'
+      raw_chunk = @raw_dotfile.split("{")[1].split("}")[0].strip
+      # pull out the header
+      raw_header = raw_chunk.match(/([\w\s*=".,\s\[\]_\\]+;)*/m)[0]
+      # find body by chopping header off chunk
+      raw_body = raw_chunk.sub(raw_header, "")
+      # split the body on '>];', which delimits the tables section
+      raw_connections = raw_body.split(">];")[-1].strip
+      # split out the tables section from the body
+      raw_tables = raw_body.split(">];")[0 .. -2].join(">];").strip + " \n>];"
+
+      # assemble the output hash
+      @graph_type = @raw_dotfile.match(/\A\s*((?:di)?graph)/)[1]
+      @title = @raw_dotfile.match(/\A\s*(?:di)?graph\s*(\w+)/)[1]
+      @header = parse_header(raw_header, ";")
+      @nodes = parse_nodes(raw_tables)
+      @connections = parse_connections(raw_connections)
+    end
+
+    def parse_header(raw_header, delimiter)
+      temp = {}
+      raw_header.scan(/(\w+)(?:\s*=?\s*)(?:["|\[](.+?)["|\]]#{delimiter})/m).each do |n|
+        if n[1].include?("=")
+          temp[n[0]] = parse_header(n[1], ",")
+        else
+          temp[n[0]] = n[1].strip
+        end
+      end
+      return temp
+    end
+
+    def chop_tables(raw_tables)
+      {}.tap do |output|
+        raw_tables.scan(/\s*\"*([\w:]+)\"*\s*\[\w+\s*=\s*<(.+?)>\];/m).each do |n|
+          output[ n[0].gsub('\"', '').strip ] = n[1].strip
+        end
+      end
+    end
+
+    def parse_nodes(raw_tables)
+      result = []
+      chop_tables(raw_tables).each do |name, table|
+        node = {:name => name.sub("m_", "")}
+        node[:fields] = []
+        if table.include?("|")
+          table.split("|")[1].scan(/port="([\w:]+)">[^<]+<[^>]+>(.+?)</m).each do |pair|
+            node[:fields] << { :name => pair[0], :type => pair[1] }
+          end
+        end
+        result << node
+      end
+      result
+    end
+
+    def parse_connections(node_chunk)
+      output = []
+      node_chunk.split("\n").each do |this_line|
+        this_connection = {}
+        temp = this_line.split("->")
+        this_connection[:start_node] = temp[0].gsub('"', '').gsub('\\', '').sub('m_', '').strip
+        this_connection[:end_node] = temp[1].split("[")[0].gsub('"', '').gsub('\\', '').sub('m_', '').strip
+        tokens = temp[1].split("[")[1].split("]")[0].split(",")
+        tokens.each do |token_string|
+          token_pair = token_string.split("=")
+          this_connection[token_pair[0].strip.gsub('"', '').gsub('\\', '').to_sym] = token_pair[1].strip.gsub('"', '').gsub('\\', '')
+        end
+        output << this_connection
+      end
+      return output
+    end
+  end # end DotFile class
+
+end # end Cabbage module

data/lib/cabbage/email/email.rb

@@ -0,0 +1,148 @@
+require_relative "parser"
+require_relative "mime_part"
+module Cabbage
+  class Email
+    include EmailParser
+
+    def initialize(source = "")
+      @raw_source = ""
+      @raw_parsed = {}
+      @header = {}
+      @original_keys = {}
+      @parts = []
+      @multipart = false
+      if source != nil && source.class.to_s == "String"
+        if source.include?("\n")
+          @raw_source = source
+          parse()
+        else
+          load_and_parse(source)
+        end
+      else
+        raise "Bad input to Cabbage::Email#new."
+      end
+    end
+
+    attr_reader :raw_source, :raw_parsed, :header, :original_keys, :parts, :multipart
+
+    def method_missing(m, *args, &block)
+      if @header.keys.include?(m.intern)
+        @header[m.intern]
+      else
+        raise "undefined method in Cabbage::Email"
+      end
+    end
+
+    def load(filename)
+      open(filename) {|f| @raw_source = f.read }
+    end
+
+    def load_and_parse(filename)
+      open(filename) {|f| @raw_source = f.read }
+      parse()
+    end
+
+    def parse
+      if @raw_source.empty?
+        puts "Nothing to parse."
+        return false
+      else
+        @raw_parsed = EmailParser.parse_email(@raw_source)
+      end
+      @header = @raw_parsed[:header]
+      @original_keys = @raw_parsed[:original_keys]
+      if header[:content_type].include?("multipart")
+        @multipart = true
+        make_flat(@raw_parsed).each do |raw_part|
+          @parts << MimePart.new(raw_part)
+        end
+      else
+        make_flat(@raw_parsed).each do |raw_part|
+          @parts << MimePart.new(raw_part)
+        end    
+      end
+      return true
+    end
+
+    def multipart?
+      @multipart
+    end
+
+    def [](key)
+      if @header.has_key?(key)
+        @header[key]
+      elsif key == :body
+        self.body
+      elsif self.mime_types.include?(key)
+        @parts[self.mime_types.index(key)].body
+      elsif key.class == FixNum
+
+      else
+        nil
+      end
+    end
+
+    def keys
+      @header.keys + [:body] + self.mime_types 
+    end
+
+    def attachments
+      [].tap do |output|
+        @parts.each do |part|
+          output << part if part.attachment?
+        end
+      end
+    end
+
+    # returns an array of strings representing available
+    # mime types in the array of mime parts.
+    def mime_types
+      [].tap do |result|
+        @parts.each do |part|
+          result << part.content_type
+        end
+      end
+    end
+
+    def body(type = "text/plain")
+      if @multipart
+        if self.mime_types.include?(type)
+          @parts[self.mime_types.index(type)].body
+        elsif @parts.size > 0
+          @parts[0].body
+        else
+          nil
+        end
+      else
+        @raw_parsed[:body]
+      end
+    end
+
+    #####################################################################
+    ########################## PRIVATE METHODS ##########################
+    #####################################################################
+
+    private
+
+    def make_flat(tree)
+      results = []
+
+      if tree[:body].class == Hash
+        tree[:body].each do |this_part|
+          if this_part[:header][:content_type] =~ /^multipart/
+            results << make_flat(this_part)
+          else
+            results << this_part
+          end
+        end
+      elsif tree[:body].class == String
+        results << tree
+      else
+        # something went wrong
+      end
+      return results.flatten
+    end
+
+  end # end Message class
+
+end # end Jmail module

data/lib/cabbage/email/mime_part.rb

@@ -0,0 +1,38 @@
+module Cabbage
+  class MimePart
+
+    def initialize(raw_part)
+      @raw_source = raw_part
+      @header = raw_part[:header]
+      @original_keys = raw_part[:original_keys]
+      @body = raw_part[:body]
+      @content_type = @header[:content_type].split(";")[0].strip
+    end
+    attr_accessor :raw_source, :header, :original_keys, :body, :content_type
+
+    def method_missing(m, *args, &block)
+      if @header.keys.include?(m.intern)
+        @header[m.intern]
+      else
+        raise "undefined method in Cabbage::MimePart"
+      end
+    end
+
+    def [](key)
+      @header[key]
+    end
+
+    def keys
+      @header.keys
+    end
+
+    def attachment?
+      if @header.has_key?(:content_disposition) && @header[:content_disposition].start_with?("attachment")
+        true
+      else
+        false
+      end
+    end
+
+  end
+end

data/lib/cabbage/email/parser.rb

@@ -0,0 +1,47 @@
+module Cabbage
+
+  module EmailParser
+
+    require_relative "../string_extras"
+    
+    def EmailParser.parse_email(source)
+      return {} if source.empty?
+      results = { :header => {}, :original_keys => {}, :body => [] }
+      divided = source.strip.match(/\A\s*(.+?)(?:\r\n\r\n|\n\n)(.+)/m)
+      raw_header = divided[1]
+      raw_body = divided[2]
+      raw_header.gsub(/\n\s+/, " ").split("\n").each do |this_line|
+        this_pair = this_line.split(/:\s*/, 2)
+        this_key_string = this_pair[0].strip
+        this_key_symbol = this_key_string.down_under.intern
+        this_value = this_pair[1]
+        if results[:header].has_key?(this_key_symbol)
+          unless results[:header][this_key_symbol].class == Array
+            results[:header][this_key_symbol] = [results[:header][this_key_symbol]]
+          end
+          results[:header][this_key_symbol] << this_value
+        else
+          results[:header][this_key_symbol] = this_value.strip
+          results[:original_keys][this_key_symbol] = this_key_string
+        end
+      end
+      if results[:header][:content_type].start_with?("multipart")
+        boundary = EmailParser.extract_value(results[:header][:content_type], "boundary")
+        EmailParser.break_by_boundary(raw_body, boundary).each {|n| results[:body] << EmailParser.parse_email(n)}
+      else
+        results[:body] = raw_body
+      end
+      results
+    end
+
+    def EmailParser.break_by_boundary(source, boundary)
+      source.split("--" + boundary).keep_if {|n| n != "--" && n != ""}.each {|n| n.strip!}
+    end
+
+    def EmailParser.extract_value(target_string, key)
+      target_string.match(/#{key}=["']?([^;\s"']+)/i)[1]
+    end
+
+  end # end Parser module
+
+end

data/lib/cabbage/string_extras.rb

@@ -0,0 +1,18 @@
+# a couple of extra methods for strings, to make things easier
+
+class String
+
+	# if a blank? method isn't yet defined for strings, do so
+	# here. If run within rails, this should already be
+	# defined. (via ActiveSupport)
+	if !(String.public_method_defined? :blank?)
+		def blank?
+			self !~ /\S/
+		end
+	end
+
+	def down_under
+		self.gsub("-", "_").downcase	
+	end
+
+end # end String class additions

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cabbage
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-24 00:00:00.000000000Z
+date: 2011-09-26 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &15137480 !ruby/object:Gem::Requirement
+  requirement: &12429820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *15137480
+  version_requirements: *12429820
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &15135640 !ruby/object:Gem::Requirement
+  requirement: &12425540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *15135640
+  version_requirements: *12425540
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &15133500 !ruby/object:Gem::Requirement
+  requirement: &12420200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 1.6.4
   type: :development
   prerelease: false
-  version_requirements: *15133500
+  version_requirements: *12420200
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &15128820 !ruby/object:Gem::Requirement
+  requirement: &12400380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *15128820
+  version_requirements: *12400380
 description: More to come.
 email: josh.lauer75@gmail.com
 executables: []
@@ -72,6 +72,11 @@ files:
 - VERSION
 - cabbage.gemspec
 - lib/cabbage.rb
+- lib/cabbage/dotfile/parser.rb
+- lib/cabbage/email/email.rb
+- lib/cabbage/email/mime_part.rb
+- lib/cabbage/email/parser.rb
+- lib/cabbage/string_extras.rb
 - test/helper.rb
 - test/test_cabbage.rb
 homepage: http://github.com/josh-lauer/cabbage
@@ -89,7 +94,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1830193836739110796
+      hash: 634790544501283345
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: