vobject 1.0.2

data/lib/vcalendar.rb

@@ -0,0 +1,77 @@
+require "vobject"
+require "vobject/component"
+require "vobject/vcalendar/component"
+require "vobject/vcalendar/grammar"
+require "json"
+
+class Vcalendar < Vobject::Component
+  attr_accessor :comp_name, :children, :version
+
+  class << self
+    def parse(vcf, strict)
+      Vobject::Component::Vcalendar.parse(vcf, strict)
+    end
+  end
+
+  def initialize(key, cs, err)
+    super key, cs, err
+  end
+
+  def child_class(key, val)
+    base_class = if key == :VTODO
+                   Vobject::Component::Vcalendar::ToDo
+                 elsif key == :VFREEBUSY
+                   Vobject::Component::Vcalendar::FreeBusy
+                 elsif key == :JOURNAL
+                   Vobject::Component::Vcalendar::Journal
+                 elsif key == :STANDARD
+                   Vobject::Component::Vcalendar::Timezone::Standard
+                 elsif key == :DAYLIGHT
+                   Vobject::Component::Vcalendar::Timezone::Daylight
+                 elsif key == :VTIMEZONE
+                   Vobject::Component::Vcalendar::Timezone
+                 elsif key == :VEVENT
+                   Vobject::Component::Vcalendar::Event
+                 elsif key == :VALARM
+                   Vobject::Component::Vcalendar::Alarm
+                 elsif key == :VAVAILABILITY
+                   Vobject::Component::Vcalendar::Vavailability
+                 elsif key == :AVAILABLE
+                   Vobject::Component::Vcalendar::Vavailability::Available
+                 elsif !(val.is_a?(Hash) && !val.has_key?(:value))
+                   property_base_class
+                 else
+                   Vobject::Component::Vcalendar
+                 end
+    return base_class if [:CLASS, :OBJECT, :METHOD].include?
+    camelized_key = key.to_s.downcase.split("_").map(&:capitalize).join("")
+    base_class.const_get(camelized_key) rescue base_class
+  end
+
+  private
+
+  def raise_invalid_parsing
+    raise "Vobject component parse failed"
+  end
+end
+
+class Vobject::Component::Vcalendar::ToDo < Vobject::Component::Vcalendar
+end
+class Vobject::Component::Vcalendar::Freebusy < Vobject::Component::Vcalendar
+end
+class Vobject::Component::Vcalendar::Journal < Vobject::Component::Vcalendar
+end
+class Vobject::Component::Vcalendar::Timezone < Vobject::Component::Vcalendar
+end
+class Vobject::Component::Vcalendar::Timezone::Standard < Vobject::Component::Vcalendar::Timezone
+end
+class Vobject::Component::Vcalendar::Timezone::Daylight < Vobject::Component::Vcalendar::Timezone
+end
+class Vobject::Component::Vcalendar::Event < Vobject::Component::Vcalendar
+end
+class Vobject::Component::Vcalendar::Alarm < Vobject::Component::Vcalendar
+end
+class Vobject::Component::Vcalendar::Vavailability < Vobject::Component::Vcalendar
+end
+# class Vobject::Component::Vcalendar::Vavailability::Available < Vobject::Component::Vcalendar::Vavailability
+# end

data/lib/vcard.rb

@@ -0,0 +1,67 @@
+require "vobject"
+require "vobject/component"
+
+class Vcard < Vobject::Component
+  attr_accessor :version
+
+  class << self
+    def blank(version)
+      new VERSION: { value: version }
+    end
+
+    def decode(vcard_str, version = nil)
+      version_str = version.nil? ? "4.0" : /\nVERSION:([^\n\r]+)/i.match(vcard_str)[1]
+      blank(version_str).parse(vcard_str)
+    end
+
+    def parse(vcf, version, strict)
+      hash = version == "3.0" ? Vcard::V3_0::Component.parse(vcf, strict) : Vcard::V4_0::Component.parse(vcf, strict)
+      # comp_name = hash.keys.first
+      # return self.new(comp_name, hash[:vobject][comp_name], hash[:errors] )
+      hash
+    end
+
+    private
+
+    def raise_invalid_parsing
+      raise "vCard parse failed"
+    end
+  end
+
+  def initialize(version)
+    self.version = version
+    super VCARD: { VERSION: { value: version } }
+  end
+
+  private
+
+  def name
+    :VCARD
+  end
+
+  def property_base_class
+    version == "3.0" ? Vcard::V3_0::Property : Vcard::V4_0::Property
+    # version_class.const_get(:Property)
+  end
+
+  def component_base_class
+    version == "3.0" ? Vcard::V3_0::Component : Vcard::V4_0::Component
+    # version_class.const_get(:Component)
+  end
+end
+
+def require_dir(dir)
+  base = File.expand_path("../", __FILE__)
+  Dir.glob(File.join(base, dir, "**", "*.rb")).each do |path|
+    require path.gsub(/\.rb\Z/, "")
+  end
+end
+
+require "vobject/vcard/v4_0/component"
+require "vobject/vcard/v4_0/property"
+require_dir "vobject/vcard/v4_0/component"
+require_dir "vobject/vcard/v4_0/property"
+require "vobject/vcard/v3_0/component"
+require "vobject/vcard/v3_0/property"
+require_dir "vobject/vcard/v3_0/component"
+require_dir "vobject/vcard/v3_0/property"

data/lib/vobject.rb

@@ -0,0 +1,25 @@
+module Vobject
+  class << self
+    MAX_LINE_WIDTH = 75
+    def unfold(str)
+      str.gsub(/(\r|\n|\r\n)[ \t]/, "")
+    end
+
+    # This implements the line folding as specified in
+    # http://tools.ietf.org/html/rfc6350#section-3.2
+    # NOTE: the "line" here is not including the trailing \n
+    def fold_line(line)
+      folded_line    = line[0, MAX_LINE_WIDTH]
+      remainder_line = line[MAX_LINE_WIDTH, line.length - MAX_LINE_WIDTH] || ""
+
+      max_width = MAX_LINE_WIDTH - 1
+
+      (0..((remainder_line.length - 1) / max_width)).each do |i|
+        folded_line << "\n "
+        folded_line << remainder_line[i * max_width, max_width]
+      end
+
+      folded_line
+    end
+  end
+end

data/lib/vobject/component.rb

@@ -0,0 +1,126 @@
+require "vobject"
+require "vobject/property"
+require "vobject/vcalendar/grammar"
+require "json"
+
+class Vobject::Component
+  attr_accessor :comp_name, :children, :multiple_components, :errors, :norm
+
+  def <=>(another)
+    me = self.to_norm
+    o = another.to_norm
+    me <=> o
+  end
+
+  def blank(version)
+    ingest VOBJECT: { VERSION: { value: version } }
+  end
+
+  def initialize(key, cs, err)
+    self.comp_name = key
+    raise_invalid_initialization if key != name
+    self.children = []
+    if cs.nil?
+    else
+      cs.each_key do |k|
+        val = cs[k]
+        # iteration of array || hash values is making the value a key!
+        next if k.class == Array
+        next if k.class == Hash
+        cc = child_class(k, val)
+        if val.is_a?(Hash) && val.has_key?(:component)
+          val[:component].each do |x|
+            children << cc.new(k, x, [])
+          end
+        else
+          children << cc.new(k, val)
+        end
+      end
+    end
+    self.errors = err.select { |e| !e.nil? }
+    self.norm = nil
+  end
+
+  def get_errors
+    errors
+  end
+
+  def child_class(key, val)
+    base_class = if val.is_a?(Hash) && val.has_key?(:component)
+                   component_base_class
+                 elsif !(val.is_a?(Hash) && !val.has_key?(:value))
+                   property_base_class
+                 else
+                   component_base_class
+                 end
+    return base_class if [:CLASS, :OBJECT, :METHOD].include? key
+    camelized_key = key.to_s.downcase.split("_").map(&:capitalize).join("")
+    base_class.const_get(camelized_key) rescue base_class
+  end
+
+  def to_s
+    s = "BEGIN:#{name}\n"
+    children.each do |c|
+      s << c.to_s
+    end
+    s << "END:#{name}\n"
+    s
+  end
+
+  def to_norm
+    if norm.nil?
+      s = "BEGIN:#{name.upcase}\n"
+      properties = children.select { |c| c.is_a? Vobject::Property }
+      components = children.select { |c| not c.is_a? Vobject::Property }
+      # create to_norm in advance
+      properties.each { |p| p.to_norm }
+      properties.sort.each do |p|
+        s << p.to_norm 
+      end
+      components.sort.each { |p| s << p.to_norm }
+      s << "END:#{name.upcase}\n"
+      norm = s
+    end
+    norm
+  end
+
+  def to_hash
+    a = {}
+    children.each do |c|
+      if c.is_a?(Vobject::Component)
+        a = a.merge(c.to_hash) { |_, old, new| [old, new].flatten }
+      elsif c.is_a?(Vobject::Property)
+        a = a.merge(c.to_hash) { |_, old, new| [old, new].flatten }
+      else
+        a[c.name] = c.to_hash
+      end
+    end
+    { comp_name => a }
+  end
+
+  def to_json
+    to_hash.to_json
+  end
+
+  def name
+    comp_name
+  end
+
+  private
+
+  def property_base_class
+    Vobject::Property
+  end
+
+  def component_base_class
+    Vobject::Component
+  end
+
+  def parameter_base_class
+    Vobject::Parameter
+  end
+
+  def raise_invalid_initialization
+    raise "vObject component initialization failed"
+  end
+end

data/lib/vobject/parameter.rb

@@ -0,0 +1,116 @@
+module Vobject
+  class Parameter
+    attr_accessor :param_name, :value, :multiple, :norm
+
+    def <=>(another)
+      self.to_norm <=> another.to_norm
+    end
+
+    def initialize(key, options)
+      self.param_name = key
+      if options.class == Array
+        self.multiple = []
+        options.each do |v|
+          multiple << parameter_base_class.new(key, v)
+          self.param_name = key
+        end
+      else
+        self.value = options
+      end
+      norm = nil
+      raise_invalid_initialization(key, name) if key != name
+    end
+
+    def to_s
+      # we made param names have underscore instead of dash as symbols
+      line = param_name.to_s.tr("_", "-")
+      line << "="
+      if multiple
+        arr = []
+        multiple.each { |v| arr << to_s_line(v.value.to_s) }
+        line << arr.join(",")
+      else
+        line << to_s_line(value.to_s)
+      end
+      line
+    end
+
+    def to_s_line(val)
+      # RFC 6868
+      val = val.to_s.gsub(/\^/, "^^").gsub(/\n/, "^n").gsub(/"/, "^'")
+      if val =~ /[:;,]/
+        val = '"' + val + '"'
+      end
+      val
+    end
+
+    def to_norm
+      if norm.nil?
+        line = param_name.to_s.tr("_", "-").upcase
+        line << "="
+        if multiple
+          arr = []
+          multiple.sort.each { |v| arr << to_norm_line(v.value) }
+          line << arr.join(",")
+        else
+          line << to_norm_line(value)
+        end
+        norm = line
+      end 
+      norm
+    end
+
+    def to_norm_line(val)
+      # RFC 6868
+      val = val.to_s.gsub(/\^/, "^^").gsub(/\n/, "^n").gsub(/"/, "^'")
+      #if val =~ /[:;,]/
+      val = '"' + val + '"'
+      #end
+      val
+    end
+
+    def to_hash
+      if multiple
+        val = []
+        multiple.each do |c|
+          val << c.value
+        end
+        { param_name => val }
+      else
+        { param_name => value }
+      end
+    end
+
+    private
+
+    def name
+      param_name
+    end
+
+    def parse_value(value)
+      parse_method = :"parse_#{value_type}_value"
+      parse_method = respond_to?(parse_method, true) ? parse_method : :parse_text_value
+      send(parse_method, value)
+    end
+
+    def parse_text_value(value)
+      value
+    end
+
+    def value_type
+      (params || {})[:VALUE] || default_value_type
+    end
+
+    def default_value_type
+      "text"
+    end
+
+    def parameter_base_class
+      Vobject::Parameter
+    end
+
+    def raise_invalid_initialization(key, name)
+      raise "vObject property initialization failed (#{key}, #{name})"
+    end
+  end
+end

data/lib/vobject/parametervalue.rb

@@ -0,0 +1,26 @@
+module Vobject
+  class ParameterValue
+    def initialize(val)
+      self.value = val
+    end
+    # raise_invalid_initialization if key != name
+  end
+
+  def to_s
+    value
+  end
+
+  private
+
+  def name
+    prop_name
+  end
+
+  def default_value_type
+    "text"
+  end
+
+  def raise_invalid_initialization
+    raise "vObject property initialization failed"
+  end
+end

data/lib/vobject/property.rb

@@ -0,0 +1,162 @@
+require "vobject"
+require "vobject/parameter"
+
+class Vobject::Property
+  attr_accessor :group, :prop_name, :params, :value, :multiple, :norm
+
+  def <=>(another)
+    if self.prop_name =~ /^VERSION$/i
+      -1
+    elsif another.prop_name =~ /^VERSION$/i
+      1
+    else
+      self.to_norm <=> another.to_norm
+    end
+  end
+
+  def initialize(key, options)
+    if options.class == Array
+      self.multiple = []
+      options.each do |v|
+        multiple << property_base_class.new(key, v)
+        self.prop_name = key
+      end
+    else
+      self.prop_name = key
+      if options.nil? || options.empty?
+        self.group = nil
+        self.params = []
+        self.value = nil
+      else
+        self.group = options[:group]
+        self.prop_name = key
+        unless options[:params].nil? || options[:params].empty?
+          self.params = []
+          options[:params].each do |k, v|
+            params << parameter_base_class.new(k, v)
+          end
+        end
+        # self.value = parse_value(options[:value])
+        self.value = options[:value]
+      end
+    end
+    self.norm = nil
+    raise_invalid_initialization if key != name
+  end
+
+  def to_s
+    if multiple.nil? || multiple.empty?
+      ret = to_s_line
+    else
+      arr = []
+      multiple.each do |x|
+        arr << x.to_s_line
+      end
+      ret = arr.join("")
+    end
+    ret
+  end
+
+  def to_s_line
+    line = group ? "#{group}." : ""
+    line << name.to_s.tr("_", "-")
+
+    (params || {}).each do |p|
+      line << ";#{p}"
+    end
+
+    line << ":#{value}"
+
+    line = Vobject::fold_line(line) << "\n"
+
+    line
+  end
+
+  def to_norm
+    if @norm.nil?
+      if multiple.nil? || multiple.empty?
+        ret = to_norm_line
+      else
+        arr = []
+        multiple.sort.each do |x|
+          arr << x.to_norm_line
+        end
+        ret = arr.join("")
+      end
+      @norm = ret
+    end
+    @norm
+  end
+
+  def to_norm_line
+    line = group ? "#{group}." : ""
+    line << name.to_s.tr("_", "-").upcase
+
+    (params || {}).sort.each do |p|
+      line << ";#{p.to_norm}"
+    end
+
+    line << ":#{value.to_norm}"
+
+    line = Vobject::fold_line(line) << "\n"
+
+    line
+  end
+
+
+  def to_hash
+    ret = {}
+    if multiple
+      ret[prop_name] = []
+      multiple.each do |c|
+        ret[prop_name] = ret[prop_name] << c.to_hash[prop_name]
+      end
+    else
+      ret = {prop_name => { value: value.to_hash } }
+      ret[prop_name][:group] = group unless group.nil?
+      if params
+        ret[prop_name][:params] = {}
+        params.each do |p|
+          ret[prop_name][:params] = ret[prop_name][:params].merge p.to_hash
+        end
+      end
+    end
+    ret
+  end
+
+  private
+
+  def name
+    prop_name
+  end
+
+  def parse_value(value)
+    parse_method = :"parse_#{value_type}_value"
+    parse_method = respond_to?(parse_method, true) ? parse_method : :parse_text_value
+    send(parse_method, value)
+  end
+
+  def parse_text_value(value)
+    value
+  end
+
+  def value_type
+    params ? params[0].value : default_value_type
+  end
+
+  def default_value_type
+    "text"
+  end
+
+  def property_base_class
+    Vobject::Property
+  end
+
+  def parameter_base_class
+    Vobject::Parameter
+  end
+
+  def raise_invalid_initialization
+    raise "vObject property initialization failed"
+  end
+end