ludo-roart 0.1.11

data/lib/roart/ticket_page.rb

@@ -0,0 +1,78 @@
+module Roart
+
+  module TicketPage
+
+    IntKeys = %w[id]
+
+    def to_hash
+      hash = HashWithIndifferentAccess.new
+      self.delete_if{|x| !x.include?(":")}
+      return false if self.size == 0
+      self.each do |ln|
+        ln = ln.split(":")
+        key = nil
+        if ln[0] && ln[0].match(/^CF-.+/)
+          key = ln.delete_at(0)
+          key = "cf_" + key[3..key.length].gsub(/ /, "_")
+        else
+          key = ln.delete_at(0).strip.underscore
+        end
+        value = ln.join(":").strip
+        hash[key] = value if key
+      end
+      hash["id"] = hash["id"].split("/").last.to_i
+      hash
+    end
+
+    def to_search_list_array
+      array = Array.new
+      self.each do |ticket|
+        ticket.extend(Roart::TicketPage)
+        ticket_hash = ticket.to_hash
+        array << ticket_hash if ticket_hash
+      end
+      array
+    end
+
+    def to_search_array
+      array = Array.new
+      self.delete_if{|x| !x.include?(":")}
+      raise TicketNotFoundError, "No tickets matching search criteria found." if self.size == 0
+      self.each do |ln|
+        hash = Hash.new
+        ln = ln.split(":")
+        id = ln.delete_at(0).strip.underscore
+        sub = ln.join(":").strip
+        hash[:id] = id.to_i
+        hash[:subject] = sub
+        hash[:full] = false
+        hash[:history] = false
+        array << hash
+      end
+      array
+    end
+
+# TODO: Don't throw away attachments (/^ {13})
+    def to_history_hash
+      hash = HashWithIndifferentAccess.new
+      self.delete_if{|x| !x.include?(":") && !x.match(/^ {9}/) && !x.match(/^ {13}/)}
+      self.each do |ln|
+        if ln.match(/^ {9}/) && !ln.match(/^ {13}/)
+          hash[:content] << "\n" + ln.strip if hash[:content]
+        elsif ln.match(/^ {13}/)
+          hash[:attachments] << "\n" + ln.strip if hash[:attachments]
+        else
+          ln = ln.split(":")
+          unless ln.size == 1 || ln.first == 'Ticket' # we don't want to override the ticket method.
+            key = ln.delete_at(0).strip.underscore
+            value = ln.join(":").strip
+            hash[key] = IntKeys.include?(key) ? value.to_i : value
+          end
+        end
+      end
+      hash
+    end
+
+  end
+
+end

data/lib/roart/validations.rb

@@ -0,0 +1,230 @@
+module Roart
+
+  class Errors
+    include Enumerable
+
+    def initialize(obj)
+      @base, @errors = obj, {}
+    end
+
+    def add_to_base(msg)
+      add(:base, msg)
+    end
+
+    def add(field, message)
+      @errors[field.to_sym] ||= []
+      @errors[field.to_sym] << message
+    end
+
+    def on_base
+      on(:base)
+    end
+
+    def on(field)
+      errors = @errors[field.to_sym]
+      return nil if errors.nil?
+      errors
+    end
+
+    alias :[] :on
+
+    def each
+      @errors.each_key { |attr| @errors[attr].each { |msg| yield attr, msg } }
+    end
+
+    # Returns true if no errors have been added.
+    def empty?
+      @errors.empty?
+    end
+
+    # Removes all errors that have been added.
+    def clear
+      @errors = {}
+    end
+
+    # Returns the total number of errors added. Two errors added to the same attribute will be counted as such.
+    def size
+      @errors.values.inject(0) { |error_count, attribute| error_count + attribute.size }
+    end
+
+    alias_method :count, :size
+    alias_method :length, :size
+
+  end
+
+  module Validations
+
+    def self.included(model)
+      model.extend ClassMethods
+
+    end
+
+    class Validators
+
+      def initialize
+        @validators = []
+      end
+
+      def add(validator)
+        @validators << validator
+      end
+
+      def validate(obj)
+        obj.errors.clear
+        @validators.each{|validator| validator.call(obj)}
+      end
+
+    end
+
+    module ClassMethods
+
+      ALL_RANGE_OPTIONS = [ :is, :within, :in, :minimum, :min, :maximum, :max ].freeze
+      ALL_NUMERICALITY_CHECKS = { :greater_than => '>', :greater_than_or_equal_to => '>=',
+                                  :equal_to => '==', :less_than => '<', :less_than_or_equal_to => '<=',
+                                  :odd => 'odd?', :even => 'even?', :only_integer => 'is_a?' }.freeze
+
+      def validator
+        @validator ||= Validators.new
+      end
+
+      def validates_presence_of(*args)
+        args.each do |field|
+          validator_proc = lambda do |obj|
+            if obj.send(field.to_sym).nil? || obj.send(field.to_sym).blank?
+              obj.errors.add(field.to_sym, "Can't Be Blank")
+            end
+          end
+          self.validator.add(validator_proc)
+        end
+      end
+
+      def validates_format_of(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        args.each do |field|
+          validator_proc = lambda do |obj|
+            unless obj.send(field.to_sym).match(options[:format])
+              obj.errors.add(field.to_sym, "Wrong Format")
+            end
+          end
+          self.validator.add(validator_proc)
+        end
+      end
+
+      def validates_length_of(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        # Ensure that one and only one range option is specified.
+        range_options = ALL_RANGE_OPTIONS & options.keys
+        case range_options.size
+        when 0
+          raise ArgumentError, 'Range unspecified.  Specify the :within, :maximum, :minimum, or :is option.'
+        when 1
+          # Valid number of options; do nothing.
+        else
+          raise ArgumentError, 'Too many range options specified.  Choose only one.'
+        end
+
+        option = range_options.first
+        option_value = options[range_options.first]
+        key = {:is => :wrong_length, :minimum => :too_short, :maximum => :too_long}[option]
+        custom_message = options[:message] || options[key]
+
+        args.each do |field|
+          case option
+          when :within, :in
+            raise ArgumentError, ":#{option} must be a Range" unless option_value.is_a?(Range)
+            validator_proc = lambda do |obj|
+              if obj.send(field.to_sym).length < option_value.begin
+                obj.errors.add(field.to_sym, "Must be more than #{option_value.begin} characters.")
+              end
+              if obj.send(field.to_sym).length > option_value.end
+                obj.errors.add(field.to_sym, "Must be less than #{option_value.end} characters")
+              end
+            end
+            self.validator.add(validator_proc)
+          when :min, :minium
+            raise ArgumentError, ":#{option} must be an Integer" unless option_value.is_a?(Integer)
+            validator_proc = lambda do |obj|
+              if obj.send(field.to_sym).length < option_value
+                obj.errors.add(field.to_sym, "Must be more than #{option_value} characters.")
+              end
+            end
+            self.validator.add(validator_proc)
+          when :max, :maxium
+            raise ArgumentError, ":#{option} must be an Integer" unless option_value.is_a?(Integer)
+            validator_proc = lambda do |obj|
+              if obj.send(field.to_sym).length > option_value
+                obj.errors.add(field.to_sym, "Must be less than #{option_value} characters.")
+              end
+            end
+            self.validator.add(validator_proc)
+          when :is
+            raise ArgumentError, ":#{option} must be an Integer" unless option_value.is_a?(Integer)
+            validator_proc = lambda do |obj|
+              unless obj.send(field.to_sym).length == option_value
+                obj.errors.add(field.to_sym, "Must be #{option_value} characters.")
+              end
+            end
+            self.validator.add(validator_proc)
+          end
+        end
+      end
+
+      alias_method :validates_size_of, :validates_length_of
+
+      def validates_numericality_of(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        numericality_options = ALL_NUMERICALITY_CHECKS.keys & options.keys
+        args.each do |field|
+          numericality_options.each do |option|
+            validator_proc = case option
+            when :only_integer
+              lambda do |obj|
+                unless obj.send(field.to_sym).send(ALL_NUMERICALITY_CHECKS[option], Integer )
+                  obj.errors.add(field.to_sym, "Must be #{ALL_NUMERICALITY_CHECKS[option]}.")
+                end
+              end
+            when :even, :odd
+              lambda do |obj|
+                if obj.send(field.to_sym).send("is_a?".to_sym, Integer) == true
+                  unless obj.send(field.to_sym).send(ALL_NUMERICALITY_CHECKS[option] )
+                    obj.errors.add(field.to_sym, "Must be #{ALL_NUMERICALITY_CHECKS[option]}.")
+                  end
+                else
+                  obj.errors.add(field.to_sym, "Must be an #{option} Integer.")
+                end
+              end
+            else
+              raise ArgumentError, ":#{option} must be a number" unless options[option].is_a?(Numeric)
+              lambda do |obj|
+                unless obj.send(field.to_sym).send(ALL_NUMERICALITY_CHECKS[option], options[option] )
+                  obj.errors.add(field.to_sym, "Must be #{ALL_NUMERICALITY_CHECKS[option]}.")
+                end
+              end
+            end
+            self.validator.add(validator_proc)
+          end
+        end
+      end
+
+    end
+
+    def validator
+      self.class.validator
+    end
+
+    def valid?
+      validator.validate self
+      self.errors.size == 0
+    end
+
+    def invalid?
+      !valid?
+    end
+
+    def errors
+      @errors ||= Errors.new(self)
+    end
+
+  end
+
+end

data/roart.gemspec

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ludo-roart}
+  s.version = "0.1.11"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["PJ Davis"]
+  s.date = %q{2010-09-15}
+  s.description = %q{Interface for working with Request Tracker (RT) tickets inspired by ActiveRecord.}
+  s.email = %q{pj.davis@gmail.com}
+  s.extra_rdoc_files = ["History.txt", "README.rdoc", "spec/test_data/full_history.txt", "spec/test_data/search_ticket.txt", "spec/test_data/single_history.txt", "spec/test_data/ticket.txt"]
+  s.files = ["History.txt", "README.rdoc", "Rakefile", "lib/roart.rb", "lib/roart/callbacks.rb", "lib/roart/connection.rb", "lib/roart/connection_adapter.rb", "lib/roart/connection_adapters/mechanize_adapter.rb", "lib/roart/core/hash.rb", "lib/roart/core/content_formatter.rb", "lib/roart/errors.rb", "lib/roart/history.rb", "lib/roart/roart.rb", "lib/roart/ticket.rb", "lib/roart/ticket_page.rb", "lib/roart/validations.rb", "roart.gemspec", "spec/roart/callbacks_spec.rb", "spec/roart/connection_adapter_spec.rb", "spec/roart/connection_spec.rb", "spec/roart/core/hash_spec.rb", "spec/roart/history_spec.rb", "spec/roart/roart_spec.rb", "spec/roart/ticket_page_spec.rb", "spec/roart/ticket_spec.rb", "spec/roart/validation_spec.rb", "spec/roart_spec.rb", "spec/spec_helper.rb", "spec/test_data/full_history.txt", "spec/test_data/search_ticket.txt", "spec/test_data/single_history.txt", "spec/test_data/ticket.txt"]
+  s.homepage = %q{http://github.com/pjdavis/roart}
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{roart}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Interface for working with Request Tracker (RT) tickets inspired by ActiveRecord}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<mechanize>, [">= 1.0.0"])
+      s.add_runtime_dependency(%q<activesupport>, [">= 2.0.0"])
+      s.add_development_dependency(%q<bones>, [">= 2.5.1"])
+    else
+      s.add_dependency(%q<mechanize>, [">= 1.0.0"])
+      s.add_dependency(%q<activesupport>, [">= 2.0.0"])
+      s.add_dependency(%q<bones>, [">= 2.5.1"])
+    end
+  else
+    s.add_dependency(%q<mechanize>, [">= 1.0.0"])
+    s.add_dependency(%q<activesupport>, [">= 2.0.0"])
+    s.add_dependency(%q<bones>, [">= 2.5.1"])
+  end
+end

data/spec/roart/callbacks_spec.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), %w[ .. spec_helper])
+
+describe 'ticket callbacks' do
+
+  describe 'create callbacks' do
+    
+    before do
+      post_data = @payload = {:queue => 'My Queue', :subject => 'A New Ticket'}
+      post_data.update(:id => 'ticket/new')
+      post_data = to_content_format(post_data)
+      mock_connection = mock('connection')
+      mock_connection.should_receive(:post).with('uri/REST/1.0/ticket/new', {:content => post_data}).and_return("RT/3.6.6 200 Ok\n\n# Ticket 267783 created.")
+      mock_connection.should_receive(:server).and_return('uri')
+      Roart::Ticket.should_receive(:connection).twice.and_return(mock_connection)
+    end
+    
+    it 'should call before_create callback' do
+      
+      ticket = Roart::Ticket.new(@payload)
+      ticket.should_receive(:before_create)
+      ticket.should_receive(:after_create)
+      ticket.save
+    end
+    
+  end
+  
+  describe 'update callbacks' do
+    
+    before do
+      @post_data = @payload = {:subject => 'A New Ticket', :queue => 'My Queue'}.with_indifferent_access
+      @post_data[:subject] = 'An Old Ticket'
+      @post_data = to_content_format(@post_data)
+      @mock_connection = mock('connection')
+      @mock_connection.should_receive(:server).and_return('uri')
+      Roart::Ticket.should_receive(:connection).twice.and_return(@mock_connection)
+    end
+    
+    it 'should call before_update callbacks' do
+      @mock_connection.should_receive(:post).with('uri/REST/1.0/ticket/1/edit', {:content => @post_data}).and_return("RT/3.6.6 200 Ok\n\n# Ticket 267783 updated.")
+      ticket = Roart::Ticket.send(:instantiate, @payload.update(:id => 1))
+      ticket.instance_variable_set("@saved", false)
+      ticket.should_receive(:before_update)
+      ticket.should_receive(:after_update)
+      ticket.save
+    end
+    
+  end
+
+end

data/spec/roart/connection_adapter_spec.rb

@@ -0,0 +1,11 @@
+
+require File.join(File.dirname(__FILE__), %w[ .. spec_helper])
+
+describe "ConnectionAdapter" do
+  
+  it 'should give us back a connection' do
+    Roart::ConnectionAdapters::MechanizeAdapter.should_receive(:new).with(:adapter => 'mechanize').and_return(mock('mechanize'))
+    Roart::ConnectionAdapter.new(:adapter => 'mechanize')
+  end
+
+end

data/spec/roart/connection_spec.rb

@@ -0,0 +1,54 @@
+
+require File.join(File.dirname(__FILE__), %w[ .. spec_helper])
+
+describe "Connection" do
+
+  before do
+    @options = {:server => 'server', :user => 'user', :pass => 'pass', :adapter => 'whatev'}
+  end  
+  
+  it "should lazy load connection adapter" do
+    @options[:adapter] = 'mechanize'
+    Roart::ConnectionAdapter.should_not_receive(:new)
+    connection = Roart::Connection.new(@options)
+  end
+
+  it 'should raise an exception if it doesnt have all the options' do
+    lambda{Roart::Connection.new(:user => 'bad')}.should raise_error
+  end
+  
+  it 'should give us the rest path' do
+    connection = Roart::Connection.new(@options)
+    connection.rest_path.should == 'server/REST/1.0/'
+  end
+  
+  it 'should give us back the whole thing' do
+    @options[:adapter] = 'mechanize'
+    mock_mech = mock('mech')
+    Roart::ConnectionAdapters::MechanizeAdapter.should_receive(:new).with(@options).and_return(mock_mech)
+    mock_mech.should_receive(:login).with(@options)
+    mock_mech.should_receive(:get).with('uri').and_return('body')
+    connection = Roart::Connection.new(@options)
+    connection.get('uri').should == 'body'
+  end
+
+  describe 'get and post' do
+    before do
+      @agent = mock("agent").as_null_object
+      Roart::ConnectionAdapter.should_receive(:new).and_return(@agent)
+    end
+  
+    it 'should respond to get' do
+      @agent.should_receive(:get).with('some_uri').and_return('body')
+      connection = Roart::Connection.new(@options)
+      connection.get("some_uri").should == 'body'
+    end
+  
+    it 'should respond to post' do
+      @agent.should_receive(:post).with('some_uri', 'a payload').and_return('body')
+      connection = Roart::Connection.new(@options)
+      connection.post("some_uri", "a payload").should == 'body'
+    end
+  end
+  
+end