acts_as_sdata 1.0.0 → 1.0.1

data/.gitignore

@@ -1,2 +1,4 @@
 nbproject
-.idea
+.idea
+*.gemspec
+pkg

data/Rakefile

@@ -5,7 +5,6 @@ begin
 
   Jeweler::Tasks.new do |gemspec|
     gemspec.name = "acts_as_sdata"
-    gemspec.version = '1.0.0'
     gemspec.authors = ["Daniel Vartanov", "Eugene Gilburg", "Michael Johnston"].sort
     gemspec.email = "dan@vartanov.net"
     gemspec.homepage = "http://sdata.sage.com/"

data/VERSION

@@ -1 +1 @@
-0.0.1
+1.0.1

data/lib/s_data.rb

@@ -0,0 +1,88 @@
+require 'active_support'
+require 'action_controller'
+require 'atom' # TODO: add ratom _dependency_
+
+module SData
+  class << self
+    def sdata_name(klass)
+      case klass
+      when SData::VirtualBase
+        klass.sdata_name
+      when Class
+        klass.respond_to?(:sdata_name) ? klass.sdata_name : nil
+      when String
+        klass.demodulize
+      end
+    end
+    
+    def sdata_url_component(klass)
+      SData.sdata_name(klass).camelize(:lower)
+    end
+    
+    def sdata_collection_url_component(klass)
+      SData.sdata_url_component(klass).pluralize
+    end
+    
+    def config
+      unless @config
+        @config = YAML.load_file(File.join(File.dirname(__FILE__), '..', 'config','sdata.yml'))
+        app_config_file = ENV['SDATA_CONFIG_FILE']
+        app_config_file ||= File.join(RAILS_ROOT, 'config','sdata.yml') if defined?(RAILS_ROOT)
+        @config = @config.deep_merge(YAML.load_file(app_config_file)) unless app_config_file.nil?
+        @config = @config.with_indifferent_access
+        @config[:contracts] ||= []
+        @config[:defaultContract] ||= @config[:contracts].first
+        @config[:defaultContract] ||= "crmErp"
+        @config[:contract_namespace] ||= "SData::Contracts"        
+      end
+      @config
+    end
+    
+    def config=(conf)
+      @config = conf.with_indifferent_access
+    end
+    
+    def sdata_contract_name(klassname)
+      if (klassname =~ /#{@config[:contract_namespace]}::([^:]*)::/)
+        $~[1].camelize(:lower)
+      else
+        raise "Cannot determine sdata_contract_name for #{klassname}"
+      end
+    end
+    
+    
+    def contract_namespaces
+      config[:contracts].map{|contract| "#{config[:contract_namespace]}::#{contract.camelize}"}
+    end
+    
+    # this is pby expensive and will have to be optimized by using const_get directly
+    # RADAR: this assumes resource names are unique across contracts. To change that must refactor sd_uuid to either
+    # have a contract attr or pby better just store fully qualified name in sd_class
+    def resource_class(klassname)
+      contract_namespaces.each do |ns|
+        begin
+          return "#{ns}::#{klassname}".constantize
+        rescue;end
+      end
+    end
+    
+    def store_path
+      #TODO: remove dataset=nil and modify calls accordingly. dataset should not be implied at this level
+      ['sdata', config[:application], config[:defaultContract]].compact.join('/')
+    end
+
+    def base_url
+      config[:base_url].chomp('/')
+    end
+    
+    def endpoint
+      [base_url, store_path].join('/')
+    end
+    
+    def reset!
+      @config = nil
+    end
+    
+    
+  end
+end

data/test/unit/controller_mixin/diagnosis_spec.rb

@@ -45,52 +45,44 @@ describe ControllerMixin, "#sdata_collection" do
                          :params => {}
       end
 
-      #TODO: spec trying to populate xpaths for errored entries
-
-      context "when one of entries is erroneous" do
+      context "when one entry is erroneous" do
         before :each do
           @controller.sdata_options[:model].stub! :all => [EntryDiagnosisCustomer.new, Customer.new]
+          @controller.should_receive(:render) do |hash|
+            @feed = hash[:xml]
+          end
+          @controller.sdata_collection
         end
 
         it "should respond with both entries" do
-          @controller.should_receive(:render) do |hash|
-            hash[:xml].entries.size.should == 2
+          @feed.entries.size.should == 2
 
-            failed_entries = hash[:xml].entries.reject{ |e| e.diagnosis.nil? }
-            successful_entries = hash[:xml].entries.select { |e| e.diagnosis.nil? }
+          failed_entries = @feed.entries.reject{ |e| e.diagnosis.nil? }
+          successful_entries = @feed.entries.select { |e| e.diagnosis.nil? }
 
-            failed_entries.size.should == 1
-            successful_entries.size.should == 1
-          end
-
-          @controller.sdata_collection
+          failed_entries.size.should == 1
+          successful_entries.size.should == 1
         end
 
         it "should compose diagnosis entry correctly" do
-          @controller.should_receive(:render) do |hash|
-            failed_entry = hash[:xml].entries.reject{ |e| e.diagnosis.nil? }.first
+          failed_entry = @feed.entries.reject{ |e| e.diagnosis.nil? }.first
 
-            failed_entry.id.should_not be_nil
-            failed_entry.content.should_not be_nil
-            failed_entry.sdata_payload.should be_nil
-          end
-          @controller.sdata_collection
+          failed_entry.id.should_not be_nil
+          failed_entry.content.should_not be_nil
+          failed_entry.sdata_payload.should be_nil
         end
 
         it "should compose sdata:diagnosis properties correctly" do
-          @controller.should_receive(:render) do |hash|
-            failed_entry = hash[:xml].entries.reject{ |e| e.diagnosis.nil? }.first
-            entry = Nokogiri::XML(failed_entry.to_xml, nil, nil, Nokogiri::XML::ParseOptions::DEFAULT_XML | Nokogiri::XML::ParseOptions::NOBLANKS)
-
-            diagnosis = entry.xpath('/xmlns:entry/sdata:diagnosis').first
-            diagnosis.children.size.should == 4
-            
-            diagnosis.xpath('sdata:severity/text()').to_s.should == 'error'
-            diagnosis.xpath('sdata:sdataCode/text()').to_s.should == 'ApplicationDiagnosis'
-            diagnosis.xpath('sdata:message/text()').to_s.should == "Exception while trying to construct payload map"
-            diagnosis.xpath('sdata:stackTrace/text()').to_s.include?('/diagnosis_spec.rb').should be_true
-          end
-          @controller.sdata_collection
+          failed_entry = @feed.entries.reject{ |e| e.diagnosis.nil? }.first
+          failed_entry = parse_xml(failed_entry.to_xml)
+
+          diagnosis = failed_entry.xpath('/xmlns:entry/sdata:diagnosis').first
+          diagnosis.children.size.should == 4
+
+          diagnosis.xpath('sdata:severity/text()').to_s.should == 'error'
+          diagnosis.xpath('sdata:sdataCode/text()').to_s.should == 'ApplicationDiagnosis'
+          diagnosis.xpath('sdata:message/text()').to_s.should == "Exception while trying to construct payload map"
+          diagnosis.xpath('sdata:stackTrace/text()').to_s.include?('/diagnosis_spec.rb').should be_true
         end
 
         it "should correctly compose regular entry as well" do
@@ -99,7 +91,6 @@ describe ControllerMixin, "#sdata_collection" do
             successful_entry.id.should_not be_nil
             successful_entry.content.should_not be_nil
             successful_entry.sdata_payload.should_not be_nil
-            successful_entry.content.should_not be_nil
           end
           @controller.sdata_collection
         end
@@ -108,108 +99,141 @@ describe ControllerMixin, "#sdata_collection" do
       it "should construct multiple diagnosis elements within the same entry to describe multiple caught exceptions" do
         pending #not implemented, difficulties with rAtom
       end
-  
-      it "should construct diagnosis for caught Feed intercepting uncaught Entry exception" do      
-        #TODO: spec trying to populate xpaths for errored entries
-        @controller.sdata_options[:model].stub! :all => [FeedDiagnosisCustomer.new, Customer.new]
-        @controller.should_receive(:render) do |hash|
-          hash[:xml].entries.size.should == 1
-          hash[:xml].entries.each do |entry|
-            entry.id.should_not be_nil
-            entry.sdata_payload.should_not be_nil
-            entry.content.should_not be_nil
-            entry.diagnosis.should be_nil
+
+      context "when feed is erroneous" do
+        before :each do
+          @controller.sdata_options[:model].stub! :all => [FeedDiagnosisCustomer.new, Customer.new]
+          @controller.should_receive(:render) do |hash|
+            @feed = hash[:xml]
           end
-          hash[:xml].simple_extensions['{http://schemas.sage.com/sdata/2008/1,diagnosis}'].size.should == 1
-          feed_diagnosis = hash[:xml].simple_extensions['{http://schemas.sage.com/sdata/2008/1,diagnosis}'][0]
-          feed_diagnosis.children.detect{|x|x.name=='sdata:severity'}.children[0].to_s.should == 'error'
-          feed_diagnosis.children.detect{|x|x.name=='sdata:sdataCode'}.children[0].to_s.should == 'ApplicationDiagnosis'
-          feed_diagnosis.children.detect{|x|x.name=='sdata:message'}.children[0].to_s.should == "Exception while trying to get customer id"           
-          feed_diagnosis.children.detect{|x|x.name=='sdata:stackTrace'}.children[0].to_s.include?('/diagnosis_spec.rb').should == true
-        end
-        @controller.sdata_collection
+          @controller.sdata_collection
+        end
+
+        it "should still include healthy entry into response" do
+          @feed.entries.size.should == 1
+
+          failed_entry = @feed.entries.first
+          failed_entry.id.should_not be_nil
+          failed_entry.sdata_payload.should_not be_nil
+          failed_entry.content.should_not be_nil
+          failed_entry.diagnosis.should be_nil
+        end
+
+        it "should include feed diagnosis into response" do
+          failed_entry = parse_xml(@feed.to_xml)
+          feed_diagnoses = failed_entry.xpath('/xmlns:feed/sdata:diagnosis').first
+          feed_diagnoses.children.size.should == 1
+          diagnosis = feed_diagnoses.children.first
+
+          diagnosis.xpath('sdata:severity/text()').to_s.should == 'error'
+          diagnosis.xpath('sdata:sdataCode/text()').to_s.should == 'ApplicationDiagnosis'
+          diagnosis.xpath('sdata:message/text()').to_s.should == "Exception while trying to get customer id"
+          diagnosis.xpath('sdata:stackTrace').to_s.include?('/diagnosis_spec.rb').should == true
+        end
       end
-      
-      it "should be able to combine feed and entry exceptions" do
-        @controller.sdata_options[:model].stub! :all => [FeedDiagnosisCustomer.new, FeedDiagnosisCustomer.new, EntryDiagnosisCustomer.new, Customer.new, Customer.new]
-        @controller.should_receive(:render) do |hash|
-          hash[:xml].entries.size.should == 3
-          hash[:xml].entries.collect{|e|e if e.diagnosis.nil?}.compact.size.should == 2
-          hash[:xml].entries.collect{|e|e if !e.diagnosis.nil?}.compact.size.should == 1
-          hash[:xml].entries.each do |entry|
+
+      context "when both feed and entry are erroneous" do
+        before :each do
+          @controller.sdata_options[:model].stub! :all => [FeedDiagnosisCustomer.new, FeedDiagnosisCustomer.new, EntryDiagnosisCustomer.new, Customer.new, Customer.new]
+          @controller.should_receive(:render) do |hash|
+            @feed = hash[:xml]
+            @failed_entries = @feed.entries.reject{ |e| e.diagnosis.nil? }
+            @successful_entries = @feed.entries.select { |e| e.diagnosis.nil? }
+          end
+          @controller.sdata_collection
+        end
+
+        it "should contain all three entries" do
+          @feed.entries.size.should == 3
+
+          @failed_entries.size.should == 1
+          @successful_entries.size.should == 2
+        end
+        
+        it "should compose entry diagnosis properly" do
+          failed_entry = @failed_entries.first
+
+          failed_entry.id.should_not be_nil
+          failed_entry.content.should_not be_nil
+          failed_entry.sdata_payload.should be_nil
+
+          feed_xml = parse_xml(@feed.to_xml)
+          diagnosis = feed_xml.xpath('//xmlns:entry/sdata:diagnosis').first
+          diagnosis.xpath('sdata:severity/text()').to_s.should == 'error'
+          diagnosis.xpath('sdata:sdataCode/text()').to_s.should == 'ApplicationDiagnosis'
+          diagnosis.xpath('sdata:message/text()').to_s.should == "Exception while trying to construct payload map"
+        end
+        
+        it "should compose healthy entries properly" do
+          @successful_entries.each do |entry|
             entry.id.should_not be_nil
             entry.content.should_not be_nil
-            if entry.diagnosis.nil?
-              entry.sdata_payload.should_not be_nil
-            else
-              entry.sdata_payload.should be_nil
-              entry.diagnosis[0].children.detect{|x|x.name=='sdata:severity'}.children[0].to_s.should == 'error'
-              entry.diagnosis[0].children.detect{|x|x.name=='sdata:sdataCode'}.children[0].to_s.should == 'ApplicationDiagnosis'
-              entry.diagnosis[0].children.detect{|x|x.name=='sdata:message'}.children[0].to_s.should == "Exception while trying to construct payload map"
-            end
+            entry.sdata_payload.should_not be_nil
           end
-          hash[:xml].simple_extensions['{http://schemas.sage.com/sdata/2008/1,diagnosis}'].size.should == 2
-          feed_diagnoses = hash[:xml].simple_extensions['{http://schemas.sage.com/sdata/2008/1,diagnosis}']
-          feed_diagnoses.each do |failed_entry|
-            failed_entry.children.detect{|x|x.name=='sdata:severity'}.children[0].to_s.should == 'error'
-            failed_entry.children.detect{|x|x.name=='sdata:sdataCode'}.children[0].to_s.should == 'ApplicationDiagnosis'
-            failed_entry.children.detect{|x|x.name=='sdata:message'}.children[0].to_s.should == "Exception while trying to get customer id"
+        end
+
+        it "should contain feed diagnoses" do
+          feed_xml = parse_xml(@feed.to_xml)
+
+          feed_diagnoses = feed_xml.xpath('/xmlns:feed/sdata:diagnosis')
+          feed_diagnoses.count.should == 2
+          feed_diagnoses.each do |diagnosis|
+            diagnosis.xpath('sdata:diagnosis/sdata:severity/text()').to_s.should == 'error'
+            diagnosis.xpath('sdata:diagnosis/sdata:sdataCode/text()').to_s.should == 'ApplicationDiagnosis'
+            diagnosis.xpath('sdata:diagnosis/sdata:message/text()').to_s.should == 'Exception while trying to get customer id'
           end
         end
-        @controller.sdata_collection
       end
-      
-      it "should construct standalone exception with full xml header" do
-        @controller.stub!(:sdata_scope).and_raise(Exception.new('exception rendering collection'))
-        @controller.should_receive(:render) do |hash|
-          hash[:xml].class.should == LibXML::XML::Document
-          hash[:xml].root.name.should == "sdata:diagnoses"
-          hash[:xml].root.children.size.should == 1
-          hash[:xml].root.children[0].name.should == "sdata:diagnosis"
-          hash[:xml].root.children[0].children.size.should == 4
-          attributes = hash[:xml].root.children[0].children.collect{|c|c.name}.sort
-          attributes.should == ["sdata:message", "sdata:sdataCode", "sdata:severity", "sdata:stackTrace"]
-          hash[:xml].root.children[0].children.each do |child|
-            child.children.size.should == 1
-            case child.name
-            when "sdata:message"
-              child.children[0].to_s.should == "exception rendering collection"
-            when "sdata:sdataCode"
-              child.children[0].to_s.should == "ApplicationDiagnosis"
-            when "sdata:severity"
-              child.children[0].to_s.should == "error"
-            end
+
+      context "when exception is raised at the action method leve" do
+        before :each do
+          @controller.stub!(:sdata_scope).and_raise(Exception.new('exception rendering collection'))
+          @controller.should_receive(:render) do |hash|
+            @feed = hash[:xml]
           end
+          @controller.sdata_collection
         end
-        @controller.sdata_collection
-      end
-      
 
+        it "should construct standalone exception with full xml header" do
+          @feed.class.should == LibXML::XML::Document
+          feed_xml = parse_xml(@feed.to_s)
+          feed_xml.xpath('/sdata:diagnoses/sdata:diagnosis').count.should == 1
+          diagnosis = feed_xml.xpath('/sdata:diagnoses/sdata:diagnosis').first
+          diagnosis.xpath('./node()').map(&:name_with_ns).to_set.should == ["sdata:message", "sdata:sdataCode", "sdata:severity", "sdata:stackTrace"].to_set
+
+          diagnosis.xpath("sdata:message/text()").to_s.should == "exception rendering collection"
+          diagnosis.xpath("sdata:sdataCode/text()").to_s.should == "ApplicationDiagnosis"
+          diagnosis.xpath("sdata:severity/text()").to_s.should == "error"
+        end
+      end
     end
 
     describe "given a controller which acts as sdata" do
       before :all do
         
         class NewBase < ActionController::Base
-           sdata_rescue_support
-           rescue_from Exception, :with => :global_rescue
-           def global_rescue
-             if request.env['REQUEST_URI'].match(/^\/sdata/)
-               #this case must happen in ALL rails environments (dev, test, prod, etc.)
-               sdata_global_rescue(exception, request.env['REQUEST_URI'])
-             end
-           end
-        end
-        NewBase.extend ControllerMixin
-        NewBase.extend SData::ApplicationControllerMixin
-        NewBase.acts_as_sdata  :model => Customer,
-                            :feed => { :id => 'some-unique-id',
-                                       :author => 'Test Author',
-                                       :path => '/test_resource',
-                                       :title => 'List of Test Items',
-                                       :default_items_per_page => 10,
-                                       :maximum_items_per_page => 100}
-                                         
+          extend ControllerMixin
+          extend SData::ApplicationControllerMixin
+
+          acts_as_sdata :model => Customer,
+                        :feed => { :id => 'some-unique-id',
+                                   :author => 'Test Author',
+                                   :path => '/test_resource',
+                                   :title => 'List of Test Items',
+                                   :default_items_per_page => 10,
+                                   :maximum_items_per_page => 100}
+
+          sdata_rescue_support
+
+          rescue_from Exception, :with => :global_rescue
+
+          def global_rescue
+            if request.env['REQUEST_URI'].match(/^\/sdata/)
+              #this case must happen in ALL rails environments (dev, test, prod, etc.)
+              sdata_global_rescue(exception, request.env['REQUEST_URI'])
+            end
+          end
+        end
       end
   
       before :each do

data/test/unit/spec_helpers/nokogiri_extensions.rb

@@ -13,4 +13,9 @@ module Nokogiri::ElementExtensions
   end
 end
 
-Nokogiri::XML::Element.__send__ :include, Nokogiri::ElementExtensions
+Nokogiri::XML::Element.__send__ :include, Nokogiri::ElementExtensions
+
+def parse_xml(xml)
+  options = Nokogiri::XML::ParseOptions::DEFAULT_XML | Nokogiri::XML::ParseOptions::NOBLANKS
+  Nokogiri::XML(xml, nil, nil, options)
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 0
-  - 0
-  version: 1.0.0
+  - 1
+  version: 1.0.1
 platform: ruby
 authors: 
 - Daniel Vartanov
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-26 00:00:00 +06:00
+date: 2010-06-30 00:00:00 +06:00
 default_executable: 
 dependencies: []
 
@@ -40,6 +40,7 @@ files:
 - generators/acts_as_sdata/acts_as_sdata_generator.rb
 - generators/acts_as_sdata/templates/migration.rb
 - init.rb
+- lib/s_data.rb
 - lib/s_data/active_record_extensions/base.rb
 - lib/s_data/active_record_extensions/mixin.rb
 - lib/s_data/active_record_extensions/sdata_uuid_mixin.rb