notes-structured-text-json-messages 0.1.1 → 0.1.4

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.4

data/bin/notes_structured_text_json_messages

@@ -16,6 +16,10 @@ OptionParser.new do |opts|
   opts.on("-v", "--[no-]verbose", "Run verbosely (default: true)") do |v|
     options[:verbose] = v
   end
+
+  opts.on("-m", "--mapping-file FILE", "output notes-distinguished-name <=> internet-email-address mappings to FILE") do |f|
+    options[:mapping_file] = f
+  end
 end.parse!
 
 NotesStructuredTextJsonMessages.logger = Logger.new($stderr)

data/lib/notes_structured_text_json_messages.rb

@@ -5,6 +5,7 @@ module NotesStructuredTextJsonMessages
   class << self
     attr_accessor :logger
     attr_accessor :stats
+    attr_accessor :mappings
   end
 
   module_function
@@ -13,26 +14,50 @@ module NotesStructuredTextJsonMessages
     yield logger if logger
   end
 
-  def reset_stats
-    self.stats={}
-  end
-
   def increment_stats(key)
     self.stats[key] = (self.stats[key]||0) + 1
   end
   
-  def json_messages(output_dir, input_files, options={})
-    reset_stats
-    [*input_files].each do |input_file|
-      File.open(input_file, "r") do |input|
-        json_messages_from_stream(output_dir, input, options)
+  def collect_mapping(addr1, addr2)
+    self.mappings << [addr1, addr2] if self.mappings
+  end
+
+  def with_mappings(options)
+    mapping_file = options[:mapping_file]
+    log{|logger| logger.info "using mapping_file: #{options[:mapping_file]}"} if mapping_file
+    self.mappings=[]
+    yield
+  ensure
+    if mapping_file
+      File.open(mapping_file, "w") do |output|
+        output << "[\n"
+        output << self.mappings.map(&:to_json).join(",\n")
+        output << "\n]"
       end
     end
-    stats.each do |k,v|
+  end
+
+  def with_stats
+    self.stats={}
+    yield
+  ensure
+    self.stats.each do |k,v|
       log{|logger| logger.info("#{k}: #{v}")}
     end
   end
 
+  def json_messages(output_dir, input_files, options={})
+    with_stats do
+      with_mappings(options) do
+        [*input_files].each do |input_file|
+          File.open(input_file, "r") do |input|
+            json_messages_from_stream(output_dir, input, options)
+          end
+        end
+      end
+    end
+  end
+
   def json_messages_from_stream(output_dir, input, options={})
     block = nil
     process_block(output_dir, block, options) while block=read_block(input)
@@ -138,35 +163,42 @@ module NotesStructuredTextJsonMessages
   def process_address(addr)
     if is_distinguished_name?(addr)
       name = addr[/CN=([^\/]*)/, 1]
-      { :name=>name,
-        :notes_dn=>addr}
+      h = {:notes_dn=>addr}
+      h[:name] = name if name
+      h
     else
       ta = TMail::Address.parse(addr)
       if ta.is_a?(TMail::Address)
-        { :name=>ta.name,
-          :email_address=>ta.address.downcase}
+        h = {:email_address=>ta.address.downcase}
+        h[:name] = ta.name if ta.name
+        h
       else
         log{|logger| logger.warn("addr does not parse to a TMail::Address: #{addr}")}
       end
     end
   end
 
-  def process_address_pair(inet_addr, notes_addr)
+  def process_address_pair(inet_addr, notes_addr, options)
     if inet_addr == "."
       process_address(notes_addr)
     else
-      process_address(inet_addr)
+      inet_addr = process_address(inet_addr)
+      notes_addr = process_address(notes_addr)
+
+      collect_mapping(notes_addr, inet_addr)
+
+      inet_addr
     end
   end
 
-  def process_addresses(block, inet_field, notes_field)
+  def process_addresses(block, inet_field, notes_field, options)
     inet_h = header_values(block, inet_field, :split_rfc822_addresses)
     notes_h = header_values(block, notes_field, :split_rfc822_addresses)
 
     if inet_h && notes_h
       if inet_h.length == notes_h.length
         inet_h.zip(notes_h).map do |inet_addr, notes_addr|
-          process_address_pair(inet_addr, notes_addr)
+          process_address_pair(inet_addr, notes_addr, options)
         end
       else
         raise "#{inet_field}: does not match #{notes_field}:"
@@ -188,11 +220,17 @@ module NotesStructuredTextJsonMessages
 
   def extract_json_message(block, options={})
     message_id_h = header_value(block, MESSAGE_ID) 
-    raise "no #{MESSAGE_ID}" if !message_id_h
+    if !message_id_h
+      increment_stats(:failure_no_message_id)
+      raise "no #{MESSAGE_ID}"
+    end
     message_id = strip_angles(message_id_h)
 
     posted_date_h = header_value(block, POSTED_DATE)
-    raise "no #{POSTED_DATE}" if !posted_date_h
+    if !posted_date_h
+      increment_stats(:failure_no_posted_date)
+      raise "no #{POSTED_DATE}"
+    end
     posted_date = parse_date(posted_date_h, options)
 
     in_reply_to_h = header_value(block, IN_REPLY_TO)
@@ -201,14 +239,20 @@ module NotesStructuredTextJsonMessages
     references_h = header_values(block, REFERENCES, " ")
     references = references_h.map{|r| strip_angles(r)} if references_h
 
-    froms = process_addresses(block, INET_FROM, FROM)
-    raise "no From:, or more than one From:" if !froms || froms.size>1
+    froms = process_addresses(block, INET_FROM, FROM, options)
+    if !froms || froms.size>1
+      increment_stats(:failure_from)
+      raise "no From:, or more than one From:"
+    end
     from = froms[0]
-    to = process_addresses(block, INET_TO, TO)
-    cc = process_addresses(block, INET_CC, CC)
-    bcc = process_addresses(block, INET_BCC, BCC)
+    to = process_addresses(block, INET_TO, TO, options)
+    cc = process_addresses(block, INET_CC, CC, options)
+    bcc = process_addresses(block, INET_BCC, BCC, options)
 
-    raise "no recipients" if (to||[]).size + (cc||[]).size + (bcc||[]).size == 0
+    if (to||[]).size + (cc||[]).size + (bcc||[]).size == 0
+      increment_stats(:failure_no_recipients)
+      raise "no recipients" 
+    end
     
     { :message_type=>"email",
       :message_id=>message_id,
@@ -222,7 +266,8 @@ module NotesStructuredTextJsonMessages
   end
 
   def output_json_message(output_dir, json_message)
-    fname = File.join(output_dir, MD5.hexdigest(json_message[:message_id]))
+    fname = File.join(output_dir, "#{MD5.hexdigest(json_message[:message_id])}.json")
     File.open(fname, "w"){|out| out << json_message.to_json}
   end
+
 end

data/spec/notes_structured_text_json_messages_spec.rb

@@ -5,7 +5,7 @@ describe NotesStructuredTextJsonMessages do
     it "should open each file and call json_messages_from_stream with it" do
       output_dir = Object.new
       input_files = [Object.new, Object.new]
-      options = Object.new
+      options = {}
 
       input0 = Object.new
       input1 = Object.new
@@ -34,6 +34,27 @@ describe NotesStructuredTextJsonMessages do
     end
   end
 
+  describe "with_mappings" do
+    it "should write mapping JSON if mapping_file option is given" do
+      opts = Object.new
+      mf = Object.new
+      mfs = StringIO.new
+      stub(opts).[](:mapping_file){mf}
+      mock(File).open(mf, "w"){|f,m,block| block.call(mfs)}
+
+      NotesStructuredTextJsonMessages.with_mappings(opts) do
+        NotesStructuredTextJsonMessages.collect_mapping({:notes_dn=>"CN=foo mcfoo/OU=foofoo/O=foo"}, 
+                                                        {:email_address=>"foo.mcfoo@foo.com"})
+        NotesStructuredTextJsonMessages.collect_mapping({:notes_dn=>"CN=bar mcbar/OU=barbar/O=bar"}, 
+                                                        {:email_address=>"bar.mcbar@bar.com"})
+      end
+
+      j = JSON.parse(mfs.string)
+      j.should == [[{"notes_dn"=>"CN=foo mcfoo/OU=foofoo/O=foo"}, {"email_address"=>"foo.mcfoo@foo.com"}],
+                   [{"notes_dn"=>"CN=bar mcbar/OU=barbar/O=bar"}, {"email_address"=>"bar.mcbar@bar.com"}]]
+    end
+  end
+
   describe "readblock" do
     it "should return lines read from a stream until the first empty line" do
       input = <<-EOF
@@ -240,12 +261,12 @@ EOF
 
   describe "process_address_pair" do
     it "should process_address the notes_address if the inet_address is '.'" do
-      NotesStructuredTextJsonMessages.process_address_pair(".", "CN=foo bar/OU=here/O=there").should == 
+      NotesStructuredTextJsonMessages.process_address_pair(".", "CN=foo bar/OU=here/O=there", {}).should == 
         {:name=>"foo bar", :notes_dn=>"CN=foo bar/OU=here/O=there"}
     end
 
     it "should process_address the inet_addr if the inet_address is not '.'" do
-      NotesStructuredTextJsonMessages.process_address_pair('"foo bar" <foo@bar.com>', "CN=foo bar/OU=here/O=there").should ==     
+      NotesStructuredTextJsonMessages.process_address_pair('"foo bar" <foo@bar.com>', "CN=foo bar/OU=here/O=there", {}).should ==     
         {:name=>"foo bar", :email_address=>"foo@bar.com"}
     end
   end
@@ -255,12 +276,13 @@ EOF
       inet_field = Object.new
       notes_field = Object.new
       block = Object.new
+      options = {}
 
       stub(NotesStructuredTextJsonMessages).header_values(block, inet_field, :split_rfc822_addresses){["foo", "bar"]}
       stub(NotesStructuredTextJsonMessages).header_values(block, notes_field, :split_rfc822_addresses){["foo"]}
       
       lambda {
-        NotesStructuredTextJsonMessages.process_addresses(block, inet_field, notes_field)
+        NotesStructuredTextJsonMessages.process_addresses(block, inet_field, notes_field, options)
       }.should raise_error(/does not match/)
     end
 
@@ -268,20 +290,22 @@ EOF
       inet_field = Object.new
       notes_field = Object.new
       block = Object.new
+      options={}
 
       stub(NotesStructuredTextJsonMessages).header_values(block, inet_field, :split_rfc822_addresses){["foo.mcfoo@foo.com", "bar.mcbar@bar.com"]}
       stub(NotesStructuredTextJsonMessages).header_values(block, notes_field, :split_rfc822_addresses){["CN=foo mcfoo/OU=main/O=foo", "CN=bar mcbar/OU=main/O=bar"]}
 
-      mock(NotesStructuredTextJsonMessages).process_address_pair("foo.mcfoo@foo.com", "CN=foo mcfoo/OU=main/O=foo")
-      mock(NotesStructuredTextJsonMessages).process_address_pair("bar.mcbar@bar.com", "CN=bar mcbar/OU=main/O=bar")
+      mock(NotesStructuredTextJsonMessages).process_address_pair("foo.mcfoo@foo.com", "CN=foo mcfoo/OU=main/O=foo", options)
+      mock(NotesStructuredTextJsonMessages).process_address_pair("bar.mcbar@bar.com", "CN=bar mcbar/OU=main/O=bar", options)
 
-      NotesStructuredTextJsonMessages.process_addresses(block, inet_field, notes_field)
+      NotesStructuredTextJsonMessages.process_addresses(block, inet_field, notes_field, options)
     end
 
     it "should call process_address if an inet header is present" do
       inet_field = Object.new
       notes_field = Object.new
       block = Object.new
+      options={}
 
       stub(NotesStructuredTextJsonMessages).header_values(block, inet_field, :split_rfc822_addresses){["foo.mcfoo@foo.com", "bar.mcbar@bar.com"]}
       stub(NotesStructuredTextJsonMessages).header_values(block, notes_field, :split_rfc822_addresses){nil}
@@ -289,13 +313,14 @@ EOF
       mock(NotesStructuredTextJsonMessages).process_address("foo.mcfoo@foo.com")
       mock(NotesStructuredTextJsonMessages).process_address("bar.mcbar@bar.com")
 
-      NotesStructuredTextJsonMessages.process_addresses(block, inet_field, notes_field)
+      NotesStructuredTextJsonMessages.process_addresses(block, inet_field, notes_field, options)
     end
 
     it "should call process_address if a notes header is present" do
       inet_field = Object.new
       notes_field = Object.new
       block = Object.new
+      options={}
 
       stub(NotesStructuredTextJsonMessages).header_values(block, inet_field, :split_rfc822_addresses){nil}
       stub(NotesStructuredTextJsonMessages).header_values(block, notes_field, :split_rfc822_addresses){["CN=foo mcfoo/OU=main/O=foo", "CN=bar mcbar/OU=main/O=bar"]}
@@ -303,7 +328,7 @@ EOF
       mock(NotesStructuredTextJsonMessages).process_address("CN=foo mcfoo/OU=main/O=foo")
       mock(NotesStructuredTextJsonMessages).process_address("CN=bar mcbar/OU=main/O=bar")
 
-      NotesStructuredTextJsonMessages.process_addresses(block, inet_field, notes_field)
+      NotesStructuredTextJsonMessages.process_addresses(block, inet_field, notes_field, options)
     end
     
   end
@@ -320,7 +345,7 @@ EOF
       output_stream = Object.new
       mock(output_stream).<<(json_struct.to_json){output_stream}
 
-      mock(File).open("/a/b/c/d/#{MD5.hexdigest("foo123@foo.com")}", "w") do |fn,m,block|
+      mock(File).open("/a/b/c/d/#{MD5.hexdigest("foo123@foo.com")}.json", "w") do |fn,m,block|
         block.call(output_stream)
       end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: notes-structured-text-json-messages
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 19
   prerelease: 
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 4
+  version: 0.1.4
 platform: ruby
 authors: 
 - craig mcmillan
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-26 00:00:00 +01:00
+date: 2011-04-27 00:00:00 +01:00
 default_executable: notes_structured_text_json_messages
 dependencies: 
 - !ruby/object:Gem::Dependency