vcard_mate 0.0.1

data/lib/vcard_mate/property.rb

@@ -0,0 +1,87 @@
+module VCardMate
+
+  class Property
+
+    attr_accessor :params
+    attr_accessor :values
+    attr_accessor :group
+
+    def initialize(name, *args)
+      @params = {}
+      @values = []
+      @group = nil
+
+      # Determine whether this property name has a group
+      name_parts = name.to_s.split('.', 2)
+
+      # If it has a group, set it
+      if name_parts.length > 1
+        @group = name_parts.first
+      end
+
+      # Set the name
+      @name = name_parts.last.downcase
+
+      # Build out the values/params from the passed arguments
+      args.each do |arg|
+        if arg.is_a? Hash
+          arg.each do |key, value|
+            @params[key.to_s.downcase] = value.to_s
+          end
+        else
+          @values.push arg.to_s
+        end
+      end
+    end
+
+    def self.parse(data)
+      # Gather the parts
+      data = data.strip
+      parts = data.split(':', 2)
+      values = parts.last.split(';')
+      params = parts.first.split(';')
+      name = params.shift
+      
+      # Create argument array beginning with name
+      args = [name]
+
+      # Add values to args
+      args.concat(values)
+
+      # Add params to args
+      params.each do |param|
+        keyval = param.split('=')
+        hash = Hash[keyval.first, keyval.last]
+        args.push(hash)
+      end
+
+      # Instantiate a new class with the args
+      new(*args)
+    end
+
+    def to_s
+      # Name/Group
+      name = @name.upcase
+      property = @group ? "#{@group}.#{name}" : name.upcase
+
+      # Params
+      @params.each_with_index do |(key, value), idx|
+        property << ';' if idx === 0
+        property << key.upcase << '=' << value
+      end
+
+      # Split with colon
+      property << ':'
+
+      # Values
+      @values.each_with_index do |value, idx|
+        property << ';' unless idx === 0
+        property << value
+      end
+
+      return property
+    end
+
+  end
+
+end

data/lib/vcard_mate/vcard.rb

@@ -0,0 +1,110 @@
+module VCardMate
+
+  class VCard
+
+    VCARD_PATTERN = /BEGIN:VCARD\s+(.*?)VERSION:(.+?)\s+(.+?)END:VCARD/m;
+
+    attr_accessor :version
+
+    def initialize(version = '4.0')
+      @version = version
+      @fields = {}
+      @group = nil
+    end
+
+    def parse(data)
+      match = VCARD_PATTERN.match(data)
+      if match
+        # Set version number
+        @version = match[2]
+        lines = "#{match[1]}#{match[3]}"
+
+        # Add the parsed properties to this vCard
+        lines.each_line do |line|
+          property = VCardMate::Property.parse(line)
+          add_prop(property)
+        end
+      end
+      self
+    end
+
+    def [](group)
+      @group = group
+      self
+    end
+
+    def method_missing(method, *args)
+      if args.empty?
+        # Return the property/properties when no arguments are passed
+        get_prop(method)
+      else
+        # If there's a group, add it
+        if @group
+          method = "#{@group}.#{method}"
+        end
+
+        # Add property to vCard
+        property = VCardMate::Property.new(method, *args)
+        add_prop(property)
+      end
+    end
+
+    def add_prop(property)
+      name = property.instance_variable_get(:@name)
+
+      # Create a field on the fields hash, if not already present, to house
+      # the property
+      unless @fields.has_key? name
+        @fields[name] = []
+      end
+      
+      # Add the property to the field array
+      @fields[name].push(property)
+    end
+
+    def get_prop(name)
+      field = @fields[name.to_s.downcase]
+      case field.length
+      when 0
+        nil
+      when 1
+        field.first
+      else
+        field
+      end
+    end
+
+    def to_s
+      # Start vCard
+      vcard = VCardMate::Property.new(:begin, 'VCARD').to_s << "\n"
+
+      # Add version
+      vcard << VCardMate::Property.new(:version, @version).to_s << "\n"
+
+      # Add the properties
+      @fields.each do |field, properties|
+        properties.each do |property|
+          vcard << property.to_s << "\n"
+        end
+      end
+
+      # END
+      vcard << VCardMate::Property.new(:end, 'VCARD').to_s << "\n"
+
+      # Return vCard
+      return vcard
+    end
+
+    # Aliases ##########
+
+    def name(*args)
+      n(*args)
+    end
+
+    def fullname(*args)
+      fn(*args)
+    end
+
+  end
+
+end

data/lib/vcard_mate/version.rb

@@ -0,0 +1,5 @@
+module VCardMate
+
+  VERSION = '0.0.1'
+
+end

data/lib/vcard_mate.rb

@@ -0,0 +1,19 @@
+require_relative 'vcard_mate/version'
+require_relative 'vcard_mate/vcard'
+require_relative 'vcard_mate/property'
+
+module VCardMate
+
+  class << self
+
+    def create(*args)
+      VCardMate::VCard.new(*args)
+    end
+
+    def parse(*args)
+      VCardMate::VCard.new.parse(*args)
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: vcard_mate
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Matt Morgan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-15 00:00:00.000000000Z
+dependencies: []
+description: vCard Mate is a ruby library for building and parsing vCards that supports
+  both v3.0 and v4.0.
+email: matt@mlmorg.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/vcard_mate/property.rb
+- lib/vcard_mate/vcard.rb
+- lib/vcard_mate/version.rb
+- lib/vcard_mate.rb
+homepage: http://github.com/mlmorg/vcard_mate
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Ruby vCard Builder/Parser
+test_files: []