sieve-parser 0.0.1 → 0.0.2

data/lib/sieve-parser/action.rb

@@ -27,10 +27,14 @@ module Sieve
     #@param [string] text of actions
     #@return [Array(Action)] array of Actions
     def self.parse_all(text)
-      lines = text.split("\n")
+      lines = text.scan(/^[\s]*(.+;)$|^[\s]*(.+\n\S+.*;\s*.*\n\.\n\;)/)
       actions = []
       lines.each do |line|
-        actions << self.new(line)
+        if !line[0].nil?
+          actions << self.new(line[0])
+        else
+          actions << Sieve::Vacation.parse_text(line[1])
+        end
       end
       actions
     end
@@ -39,7 +43,7 @@ module Sieve
     #@return [string] text of action
     def to_s
       text =""
-      {'type'=>@type, 'copy'=>@copy, 'target'=>@target}.each do |name,item|
+      {'type'=>@type, 'copy'=>(@copy) ? ":copy" : nil, 'target'=>@target}.each do |name,item|
         if ['target'].index(name)
           text += "\"#{item}\" " unless item.nil?
         else
@@ -60,7 +64,7 @@ module Sieve
       params = @text.split(" ")
       @type = params[0]
       if params[1]==":copy"
-        @copy = params[1]
+        @copy = true
         @target = params[2]
       else
         @target = params[1]

data/lib/sieve-parser/condition.rb

@@ -5,18 +5,23 @@ module Sieve
   class Condition
     attr_accessor :test,:not,:arg1,:arg2,:type, :text
 
-    # Create Condition object by text of condition
+    # Create Condition object by text of condition or params
     #@note Example:
     #  header :contains "Subject" "teste"
-    #@param [string] text of condition 
+    #@param [String](:text) text of condition 
+    #@param [String](:test) test of condition 
+    #@param [String](:not) not of condition 
+    #@param [String](:arg1) arg1 of condition 
+    #@param [String](:arg2) arg2 of condition 
+    #@param [String](:type) type of condition 
     #@return [Condition] Condition object parsed
-    def initialize(text=nil)
-      @text = text
-      @test=nil
-      @not=nil
-      @arg1=nil
-      @arg2=nil
-      @type=nil
+    def initialize params={}
+      @text = params[:text]
+      @test=params[:test]
+      @not=params[:not]
+      @arg1=params[:arg1]
+      @arg2=params[:arg2]
+      @type= params[:type]
       parse unless @text.nil?
     end
     # Return a array of conditions after parse the text
@@ -28,7 +33,7 @@ module Sieve
     def self.parse_all(text)
       contitions = []
       text.scan(/([\s\w:]*\"\S+\"\s\"[\sa-zA-Z0-9,\.\-\@ÁÀÃÂÇÉÈÊÍÌÓÒÔÕÚÙÜÑáàãâçéèêíìóòôõúùüñ]*\")/).each do |item|
-        contitions << self.new(item[0])
+        contitions << self.new(text:item[0])
       end
       contitions
     end

data/lib/sieve-parser/filter.rb

@@ -7,16 +7,18 @@ module Sieve
   class Filter
 
     #@note [join] can be: any, allof or anyof
-    attr_accessor :name, :type, :join, :text_filter
+    attr_accessor :name, :type, :join, :disabled, :text
 
     # Initialize the class
-    #@param [string] String of filter text
+    #@param [String](:text) String of filter text
+    #@param [Array](:conditions) Array of Conditions
+    #@param [Array](:actions) Array of Actions
     #@return [object] Object of self
-    def initialize(text_filter=nil)
-      @text_filter = text_filter
-      @conditions = []
-      @actions = []
-      parse unless @text_filter.nil?
+    def initialize params={}
+      @text = params[:text]
+      @conditions = (params[:conditions]) ? params[:conditions] : []
+      @actions = (params[:actions]) ? params[:actions] : []
+      parse unless @text.nil?
     end
 
     # Return the conditions of filter
@@ -54,25 +56,31 @@ module Sieve
       else
         text += " " + conditions[0].to_s
       end
-      text += "\n{\n    "
-      text += actions.join("\n    ")
+      text += "\n{\n\t"
+      text += actions.join("\n\t")
       text += "\n}\n"
     end
 
-    private
-    # Parse conditions, call the parse_common or parse_vacation
-    def parse
-      @text_filter[/vacation/].nil? ? parse_common : parse_vacation
+    # Is disabled or not? Return the status of filter
+    #@return [boolean] true for disabled and false for enabled
+    def disabled?
+      @disabled == true
+    end
+
+    def disable!
+      @disabled = true
     end
 
     private
-    # Parse the filter adding contitions and actions to class
-    def parse_common
+    # Parse conditions, call the parse_common or parse_vacation
+    def parse
       #regex_rules_params = "(^#.*)\nif([\s\w\:\"\.\;\(\)\,\-]+)\{([\@\<>=a-zA-Z0-9\s\[\]\_\:\"\.\;\(\)\,\-\/]+)\}$"
       #regex_rules_params2 = "(^#.*)\n(\S+)(.+)\n\{\n([\s\S]*)\}"
-      parts = @text_filter.scan(/(^#.*)\n(\S+)\s(.+)\n\{\n([\s\S]*)\}/)[0]
+      parts = @text.scan(/(^#.*)\n(\S+)\s(.+)\n\{\n([\s\S]*;)\n\}/)[0]
       parse_name(parts[0])
       @type = parts[1]
+
+      self.disable! if parts[2] =~ /.*false #/
       #if the join is true, dont have conditions...
       if parts[2] =~ /true/
         @conditions << Condition.new(type:"true")
@@ -80,24 +88,16 @@ module Sieve
         @join = parts[2][/^\S+/]
         @conditions.concat(Condition.parse_all( parts[2].scan(/\(([\S\s]+)\)/)[0][0] ))
       else
-        @conditions << Condition.new(parts[2])
+        @conditions << Condition.new(text:parts[2])
       end
 
       @actions.concat(Action.parse_all(parts[3]))
     end
 
-    private
-    # Parse the vacation filter
-    def parse_vacation
-
-    end
 
     def parse_name(text_name)
       @name = text_name.match(/#(.*)/)[1].strip
     end
   end
 
-  class Vacation
-    attr_accessor :days, :subject, :content
-  end
 end

data/lib/sieve-parser/filterset.rb

@@ -15,6 +15,9 @@ module Sieve
   class FilterSet
     attr_accessor :text_sieve
     
+    #Create FilterSet
+    #@param [String] text of sieve
+    #@return [FilterSet]
     def initialize(text_sieve=nil)
       @text_sieve = text_sieve
       @requires = []
@@ -28,12 +31,27 @@ module Sieve
       @filters
     end
 
+    # Add filter to filters of filterset
+    #@param [Filter] filter object
+    def add_filter(filter)
+      raise Exception.new("The param is not a Filter!") unless filter.class.to_s == "Sieve::Filter"
+      @filters << filter
+    end
+
     # Requires inside the script
     #@return [array] names of requires
     def requires
       @requires
     end
 
+    # Add require to requires of filterset
+    #@param [string] name of require
+    def add_require(req)
+      #TODO: Implement config of requires allowed
+      raise Exception.new("Is not a require valid!") unless req =~ /\S+/ 
+      @requires << req
+    end
+
     # Return a text of filterset
     #@return [string] text of filterset
     def to_s
@@ -50,7 +68,7 @@ module Sieve
       end
 
       @text_sieve.scan(/(^#.*\nif[\s\w\:\"\.\;\(\)\,\-]*\n\{[a-zA-Z0-9\s\@\<>=\:\[\]\_\"\.\;\(\)\,\-\/]*\n\}$)/).each do |f| 
-        @filters << Sieve::Filter.new(f[0])
+        @filters << Sieve::Filter.new(text:f[0])
       end
 
     end

data/lib/sieve-parser.rb

@@ -1,5 +1,5 @@
 module Sieve
-  %w(filterset filter action condition ).each do |entity|
+  %w(filterset filter action condition vacation).each do |entity|
     require_relative "sieve-parser/#{entity}"
   end
 end

data/sieve-parser.gemspec

@@ -2,7 +2,7 @@ require 'rubygems'
 
 spec = Gem::Specification.new do |s|
   s.name = 'sieve-parser'
-  s.version = '0.0.1'
+  s.version = '0.0.2'
   s.summary = 'A Ruby library for sieve parser'
   s.description = <<-EOF
     sieve-parser is a pure-ruby implementation for parsing and 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sieve-parser
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-25 00:00:00.000000000Z
+date: 2012-09-26 00:00:00.000000000Z
 dependencies: []
 description: ! "    sieve-parser is a pure-ruby implementation for parsing and \n
   \   manipulate the sieve scripts.\n"