virginity 0.3.31

data/lib/virginity/vcard/fields_osx.rb

@@ -0,0 +1,95 @@
+module Virginity
+
+  class RelatedNames < BaseField
+    include Params::Type
+    include FieldValues::Text
+    register_for "X-ABRELATEDNAMES"
+  end
+
+
+  class XAbLabel < BaseField
+    ABLABEL = "X-ABLabel"
+    register_for ABLABEL
+    SAFE_LABELS = %w(HOME WORK FAX CELL PREF MAIN PAGER INTERNET VOICE)
+    STRANGELABEL_MATCHER = /_\$!<(.*)>!\$_/
+    STRANGE_LABELS = {}
+    %w(HomePage Other Assistant Father Mother Parent Brother Sister Child Friend Spouse Partner Manager Anniversary).each do |v|
+      STRANGE_LABELS[v.upcase] = v
+    end
+    STRANGE_LABELS.freeze
+    #SAFECHARS = /^(.[^\"\;\:\,])*$/
+    #ALREADYQOUTED = /^\"(.*?)\"$/
+
+    def self.from_param(param, options = {})
+      raise TypeError, "expected a Param with key == \"TYPE\"" unless param.key.upcase == "TYPE"
+      from_text(param.value, options)
+    end
+
+    def to_param
+      Param.new("TYPE", text)
+    end
+
+    def self.from_text(t, options = {})
+      new(ABLABEL).tap do |label|
+        label.text = t
+        label.group = options[:group]
+      end
+    end
+
+    def self.types_to_convert_to_xablabel(field)
+      field.params('TYPE').reject do |type|
+        SAFE_LABELS.include?(type.value)
+      end
+    end
+
+    # returns an array of XAbLables
+    def self.from_field(field)
+      types_to_convert_to_xablabel(field).map { |t| from_param(t) }
+    end
+
+    def text
+      if match = STRANGELABEL_MATCHER.match(@value)
+        match[1].upcase
+      else
+        @value
+      end
+    end
+
+    def text=(text)
+      if x = STRANGE_LABELS[text.upcase]
+        @value = "_$!<#{x}>!$_"
+      else
+        @value = text
+      end
+    end
+  end
+
+
+  class XAbDate < BaseField
+    include FieldValues::Text
+    include FieldValues::DateValue
+    include Params::Type
+    register_for "X-ABDATE"
+  end
+
+
+  class XAbAdr < BaseField
+    include FieldValues::Text
+    ABADR = "X-ABADR"
+    register_for ABADR
+
+    def self.from_param(param)
+      raise TypeError unless param.is_a?(Param) and param.key.downcase == "x-format"
+      from_text(param.value)
+    end
+
+    def self.from_text(t)
+      new(ABADR, EncodingDecoding::encode_text(t))
+    end
+
+    def to_param
+      Param.new("x-format", text)
+    end
+  end
+
+end

data/lib/virginity/vcard/fields_soocial.rb

@@ -0,0 +1,45 @@
+module Virginity
+
+  class XSoocialCustom < BaseField
+    PARTS = %w(key_name value)
+    include FieldValues::StructuredText.define(PARTS)
+    register_for "X-SOOCIAL-CUSTOM"
+
+    def value
+      rewrite_old_kv!
+      super
+    end
+
+    def key_name
+      rewrite_old_kv!
+      super
+    end
+
+    def text
+      value
+    end
+
+    def text=(txt)
+      self.value = txt
+    end
+
+    def to_s
+      rewrite_old_kv!
+      super
+    end
+
+    def rewrite_old_kv!
+      if name = params('NAME')[0]
+        self.key_name, self.value = name.value, EncodingDecoding.decode_text(raw_value)
+        params.delete_if { |p| p.key == "NAME" }
+      end
+    end
+  end
+
+
+  class XSoocialRemovedCategory < BaseField
+    include FieldValues::Text
+    register_for "X-SOOCIAL-REMOVED-CATEGORY"
+  end
+
+end

data/lib/virginity/vcard/name_handler.rb

@@ -0,0 +1,151 @@
+require "virginity/vcard/fields"
+
+module Virginity
+
+  class Vcard < DirectoryInformation
+    # A Vcard-wrapper that deals with the the fields N, FN and NICKNAME.
+    #
+    # You will probably use it like this:
+    #   v = Vcard.new
+    #   v.name.given = "Bert"
+    #   puts v
+    #
+    # There are undocumented methods for getting and setting: prefix, given, additional, family, and suffix.
+    class NameHandler
+      # takes a Vcard object or a String
+      def initialize(vcard)
+        if vcard.is_a? Vcard
+          @vcard = vcard
+        else
+          @vcard = Vcard.from_vcard(vcard.to_s)
+        end
+      end
+
+      # formatted name
+      def to_s
+        fn.text
+      end
+      alias_method :formatted, :to_s
+
+      # regenerate the formatted name (that is the FN field)
+      def reset_formatted!
+        @vcard.delete(*@vcard.lines_with_name("FN"))
+        fn.text
+      end
+
+      # generate a FN field using the following fields
+      # n > nickname > org > email > impp > tel
+      def generate_fn(options = {})
+        nfield = n
+        g = nfield.given.empty? ? nil : nfield.given
+        f = nfield.family.empty? ? nil : nfield.family
+        unless [g, f].compact.empty?
+          if options[:include_nickname]
+            nick = @vcard.nicknames.empty? ? nil : "\"#{@vcard.nicknames.first.values.first}\""
+            [g, nick, f].compact.join(" ")
+          elsif options[:complete_name]
+            prefix = nfield.prefix.empty? ? nil : nfield.prefix
+            additional = nfield.additional.empty? ? nil : nfield.additional
+            suffix = nfield.suffix.empty? ? nil : nfield.suffix
+            [prefix, g, additional, f, suffix].compact.join(" ")
+          else
+            [g, f].compact.join(" ")
+          end
+        else
+          if not @vcard.nicknames.empty?
+            nicknames.first
+          elsif @vcard.organisations.first
+            @vcard.organisations.first.values.first
+          elsif @vcard.emails.first
+            @vcard.emails.first.address
+          elsif @vcard.impps.first
+            @vcard.impps.first.address
+          elsif @vcard.telephones.first
+            @vcard.telephones.first.number
+          else
+            ""
+          end
+        end
+      end
+
+      # generate the fn using the complete name including prefix, additional parts and suffix
+      def complete
+        generate_fn(:complete_name => true)
+      end
+
+      # add a fn if it's not there (since it is required by the vCard specs) and return it
+      def fn
+        @vcard.lines_with_name("FN").first || @vcard.add_field("FN:#{EncodingDecoding::encode_text(generate_fn)}")
+      end
+
+      # add a n if it's not there (since it is required by the vCard specs) and return it
+      def n
+        @vcard.lines_with_name("N").first || @vcard.add_field("N:;;;;")
+      end
+
+      Name::PARTS.each do |part|
+        class_eval <<-end_class_eval
+          def #{part}
+            n.#{part}
+          end
+
+          def #{part}=(value)
+            return value if n.#{part} == value
+            n.#{part} = value
+            reset_formatted!
+            value
+          end
+        end_class_eval
+      end
+
+      # are all parts of the N field empty? ("N:;;;;")
+      def empty?
+        Name::PARTS.all? { |part| send(part).empty? }
+      end
+
+      # an array with all nicknames
+      def nicknames
+        @vcard.nicknames.map {|n| n.values.to_a }.flatten
+      end
+
+      def add_nickname(nick)
+        @vcard << SeparatedField.new("NICKNAME", EncodingDecoding::encode_text_list([nick]))
+        reset_formatted!
+        nick
+      end
+
+      def remove_nickname(nick)
+        @vcard.nicknames.each do |nickname|
+          nickname.values.delete(nick)
+          @vcard.delete nickname if nickname.raw_value.empty? # the singular 'value' is meant here, don't change it to values!
+        end
+        reset_formatted!
+        nick
+      end
+
+      def has_nickname?(nick)
+        @vcard.nicknames.any? { |nickname| nickname.values.include?(nick) }
+      end
+
+      # merge this name with other_name; conflicting parts will raise a MergeError
+      #
+      # if the option :simple_name_resolving is true we choose the value in this name instead of raising an error. Parts that are not present in self will be filled in with the value from other_name
+      def merge_with!(other_name, options = {})
+        Name::PARTS.each do |part|
+          own, his = send(part).rstrip, other_name.send(part).rstrip
+          if own.empty?
+            send "#{part}=", his
+          elsif his.empty? or own == his
+            # then nothing needs to be done
+          else
+            # :simple_name_resolving means keep our own name, don't take over his. iow: do nothing
+            unless options[:simple_name_resolving]
+              raise MergeError, "#{part} name is different: '#{own}' and '#{his}'"
+            end
+          end
+        end
+        self
+      end
+    end
+  end
+end

data/lib/virginity/vcard/patching.rb

@@ -0,0 +1,262 @@
+require 'forwardable'
+module Virginity
+  class Vcard < DirectoryInformation
+    # before: TEL;TYPE=HOME:1234
+    # after: TEL;TYPE=HOME:1233
+    # --- clearly fixing a typo so: ---
+    # update("TEL:1234", :value => 1233)
+
+    # before: TEL;TYPE=HOME:1234
+    # after: TEL;TYPE=HOME,WORK:1234
+    # --- params changed ---
+    # update("TEL:1234", :add_param => "TYPE=WORK")
+
+    # before: TEL;TYPE=HOME:1234
+    # after: TEL;TYPE=WORK:1234
+    # --- params changed ---
+    # update("TEL:1234", :remove_param => "TYPE=HOME", :add_param => "TYPE=WORK")
+
+    # before: TEL;TYPE=HOME:1234
+    # after: TEL;TYPE=WORK:1233
+    # --- someone removed the home phone and added a new number for work ---
+    # remove("TEL:1234")
+    # add("TEL;TYPE=WORK:1233")
+    module Patching
+      class IllegalPatch < Error; end
+
+      def patch!(diff)
+        diff.apply(self)
+        self
+      end
+
+      def self.diff(before_card, after_card)
+        Diff.diff(before_card, after_card)
+      end
+
+
+      # the base class
+      class Patch
+        def self.query_for_line(line)
+          line.name + ":" + line.raw_value
+        end
+
+        def self.query_from_string(query_string)
+          q = Field.parse(query_string)
+          # at this moment all our queries are like "name : raw_value"
+          query = { :name => q.name }
+          if q.respond_to? :values
+            query[:values] = q.values.to_a
+          elsif q.respond_to? :text
+            query[:text] = q.text
+          else
+            query[:raw_value] = q.raw_value
+          end
+          query
+        end
+
+        def field_from_query(query)
+          value = query.reject { |k, v| k == :name }
+          Field.named(query[:name]) do |f|
+            value.each do |k,v|
+              f.send(k+'=', v)
+            end
+          end
+        end
+
+        def apply(vcard)
+          raise "responsibility of subclass"
+        end
+
+        def self.normalize_vcard!(vcard)
+          vcard.clean_orgs! # orgs are of variable length, but ordered, they need normalizing before we can compare them
+          # normalize categories and nicknames (actually every unpackable field)
+          vcard.fields.each do |field|
+            vcard.unpack_field!(field) if field.respond_to?(:unpacked)
+            field.clean!
+            field.params.sort!
+          end
+          # remove double lines
+          vcard.clean_same_value_fields!
+          vcard.add("N") unless vcard.lines_with_name("N").any?
+          vcard.clean_name!
+          vcard
+        end
+      end
+
+
+      # a Diff is a collection of changes, I think we can even nest them which might be a cool way of combining them
+      class Diff < Patch
+        attr_reader :changes
+        extend Forwardable
+        def_delegators :@changes, :push, :<<, :empty?, :size
+
+        def initialize(*changes)
+          @changes = changes
+        end
+
+        def self.diff(before_card, after_card)
+          patch = Diff.new
+          before, after = before_card.deep_copy, after_card.deep_copy
+          normalize_vcard!(before)
+          normalize_vcard!(after)
+          before.lines.each do |line|
+            # if the exact same line is in after then we can stop processing this line
+            # this will of course always happen for begin:vcard, end:vcard
+            next unless after.delete(line).empty?
+            q = query_from_string(line)
+            if x = after.find_first(q)
+              patch << Update.diff_lines(line, x, :query => q)
+              after.delete(x)
+            #else if "there is a line with just one or 2 characters difference in the value" or "only insignificant characters changed, like dashes in telephone numbers"
+              # patch << Update.diff_lines(line, x, :query => q)
+              # after.delete(x)
+            else
+              patch << Remove.new(q)
+            end
+          end
+          # what is left in after should be added
+          after.lines.each { |line| patch << Add.new(line.to_s) }
+          patch
+        end
+
+        def apply(vcard)
+          Patch::normalize_vcard!(vcard)
+          @changes.each { |change| change.apply(vcard) }
+        end
+
+        def to_s
+          @changes.join("\n")
+        end
+
+        def pretty_print(q)
+          @changes.each do |change|
+            pp change
+          end
+        end
+      end
+
+
+      # to add a field
+      class Add < Patch
+        attr_accessor :field
+        def initialize(line)
+          @field = Field.parse(line)
+        end
+
+        def apply(vcard)
+          vcard.add_field(@field)
+        end
+
+        def to_s
+          "Add(#{@field.inspect})"
+        end
+
+        def pretty_print(q)
+          q.text "Add #{@field}"
+        end
+      end
+
+
+      # to remove fields matching a query
+      class Remove < Patch
+        attr_accessor :query
+        def initialize(query)
+          @query = query
+        end
+
+        def apply(vcard)
+          vcard.delete(*vcard.where(@query))
+        end
+
+        def to_s
+          "Remove(#{@query.inspect})"
+        end
+
+        def pretty_print(q)
+          q.text "Remove #{@query}"
+        end
+      end
+
+
+      # to update field matching the query
+      # for automatically generated diffs this will usually only entail updates to params
+      # there is an alternative action that will be executed if there is no field to update
+      class Update < Patch
+        attr_accessor :query, :updates, :alternative
+        def initialize(query, updates, alternative = nil)
+          @query = query
+          @updates = updates
+          @alternative = alternative
+        end
+
+        def self.diff_lines(before, after, options = {})
+          Update.new(
+            options[:query] || Patch::query_from_string(before),
+            line_diff(before, after),
+            Add.new(after)
+          )
+        end
+
+        COLON = ":"
+        SEMICOLON = ";"
+        def update_field!(field)
+          @updates.each_pair do |key, value|
+            case key
+            when :value
+              field.raw_value = value
+            when :add_param
+              # params_from_string returns an array of params
+              field.params += Param::params_from_string(value + COLON)
+            when :remove_param
+              Param::params_from_string(value + COLON).each do |param_to_delete|
+                field.params.delete_if { |p| p == param_to_delete }
+              end
+            else
+              raise IllegalPatch, "#{key}, #{value}"
+            end
+          end
+        end
+
+        def apply(vcard)
+          to_update = vcard.where(@query)
+          if to_update.empty?
+            # if the field has been deleted in the meantime on the server, the patch adds it again
+            # to_update << vcard.add_field(field_from_query(@query)) if to_update.empty?
+            @alternative.apply(vcard) unless @alternative.nil?
+          else
+            to_update.each { |field| update_field!(field) }
+          end
+        end
+
+        def to_s
+          s = "Update(#{@query.inspect}, #{@updates.map {|k,v| "#{k}(#{v.inspect})" }.join(", ")})"
+          if @alternative
+            s << " else { #{alternative} }"
+          end
+        end
+
+        def pretty_print(q)
+          q.text "Replace #{query} with #{@updates.map {|k,v| "#{k}(#{v.inspect})" }.join(", ")})"
+          if @alternative
+            q.text " else { #{alternative} }"
+          end
+        end
+
+      protected
+        # before and after are content lines
+        def self.line_diff(before, after)
+          patch = {}
+          patch[:value] = after.raw_value unless before.raw_value == after.raw_value
+          unless (to_remove = before.params - after.params).empty?
+            patch[:remove_param] = Param.params_to_s(to_remove)
+          end
+          unless (to_add = after.params - before.params).empty?
+            patch[:add_param] = Param.params_to_s(to_add)
+          end
+          patch
+        end
+      end
+
+    end
+  end
+end