zilkey-active_api 0.1.0

data/lib/active_api/simple_type.rb

@@ -0,0 +1,102 @@
+module ActiveApi
+  class SimpleType
+    include Builder
+
+    class << self
+      def formats
+        standard_names = [
+          :base64Binary,
+          :boolean,
+          :date,
+          :dateTime,
+          :dateTimeStamp,
+          :decimal,
+          :integer,
+          :long,
+          :int,
+          :short,
+          :byte,
+          :nonNegativeInteger,
+          :positiveInteger,
+          :unsignedLong,
+          :unsignedInt,
+          :unsignedShort,
+          :unsignedByte,
+          :nonPositiveInteger,
+          :negativeInteger,
+          :double,
+          :duration,
+          :dayTimeDuration,
+          :yearMonthDuration,
+          :float,
+          :gDay,
+          :gMonth,
+          :gMonthDay,
+          :gYear,
+          :gYearMonth,
+          :hexBinary,
+          :precisionDecimal,
+          :string,
+          :normalizedString,
+          :token,
+          :language,
+          :time
+        ].map do |format|
+          {format.to_s.underscore.to_sym => format}
+        end
+
+        custom_names = [
+          {:any_uri => :anyURI},
+          {:notation => :NOTATION},
+          {:qname => :QName},
+          {:name => :Name},
+          {:nc_name => :NCName},
+          {:entity => :ENTITY},
+          {:id => :ID},
+          {:idref => :IDREF},
+          {:nmtoken => :NMTOKEN},
+        ]
+
+        standard_names + custom_names
+      end
+
+      def default_format_proc
+        proc { |value| value }
+      end
+
+      def format_procs
+        {
+          :normalized_string => proc {|value| value },
+          :token =>             proc {|value| value },
+          :date_time =>         proc {|value| value.strftime("%Y-%m-%dT%H:%M:%S%Z") },
+          :time =>              proc {|value| value.strftime("%H:%M:%S%Z") },
+          :date =>              proc {|value| value.strftime("%Y-%m-%d") },
+          :any_uri =>           proc {|value| URI.escape(value) }
+        }
+      end
+    end
+
+    attr_reader :text, :node, :format
+
+    def initialize(text, options)
+      @text   = text
+      @node   = options[:node]
+      @format = options[:format]
+    end
+
+    def append(hash)
+      hash[node] = formatted_text
+    end
+
+    protected
+
+    def build(builder)
+      builder.send "#{node}_", formatted_text
+    end
+
+    def formatted_text
+      (self.class.format_procs[format] || self.class.default_format_proc).call(text)
+    end
+
+  end
+end

data/lib/active_api.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'activesupport'
+require 'nokogiri'
+
+require 'uri'
+
+require 'active_api/builder'
+require 'active_api/has_definition'
+require 'active_api/collection'
+require 'active_api/complex_type'
+require 'active_api/simple_type'
+require 'active_api/field'
+require 'active_api/schema'
+require 'active_api/definition'

data/spec/active_api/complex_type_spec.rb

@@ -0,0 +1,27 @@
+require 'spec/spec_helper'
+
+module ActiveApi
+  describe ComplexType do
+
+    before do
+      @article = Article.new
+      @article.id = 1
+      @article.title = "Some title"
+
+      @schema = Schema.version(:v1) do |xsl|
+        xsl.define :article do |t|
+          t.string :title
+        end
+      end
+    end
+
+    describe "with a definition with fields" do
+      it "emits the node and all fields within the node" do
+        element = ComplexType.new @article, :node => :article, :schema => @schema
+        doc = element.build_xml.doc
+        doc.xpath("/article/title").first.inner_text.should == @article.title
+      end
+    end
+
+  end
+end

data/spec/active_api/definition_spec.rb

@@ -0,0 +1,31 @@
+require 'spec/spec_helper'
+
+module ActiveApi
+  describe Definition do
+
+    describe "#class_symbol" do
+      it "returns what is passed in" do
+        Definition.new(:definition_name => :article).definition_name.should == :article
+      end
+    end
+
+    describe "#fields" do
+      it "is empty by default" do
+        Definition.new(:definition_name => :article).fields.should be_empty
+      end
+    end
+
+    [:string, :has_many, :belongs_to, :has_one].each do |method_name|
+      describe "##{method_name}" do
+        it "adds a #{method_name} field with the options" do
+          definition = Definition.new(:definition_name => :article)
+          definition.send method_name, :title
+          definition.fields.length.should == 1
+          definition.fields.first.type.should == method_name
+          definition.fields.first.name.should == :title
+        end
+      end
+    end
+    
+  end
+end

data/spec/active_api/field_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module ActiveApi
+  describe Field do
+    it "has a type" do
+      definition = Field.new :type => :string
+      definition.type.should == :string
+    end
+
+    it "has a name" do
+      definition = Field.new :name => :title
+      definition.name.should == :title
+    end
+  end
+end

data/spec/active_api/schema_spec.rb

@@ -0,0 +1,59 @@
+require 'spec/spec_helper'
+
+module ActiveApi
+  describe Schema do
+
+    before do
+      Schema.version(:v1) do |schema|
+        schema.define :article do |t|
+          t.string :title
+          t.has_many :comments
+        end
+      end
+    end
+
+    describe ".define" do
+      describe "with a single field" do
+
+        it "adds one definition of the correct type" do
+          schema = Schema.find(:v1)
+          schema.definitions.length.should == 1
+          definition = schema.definitions.first
+          definition.should be_kind_of(Definition)
+          definition.definition_name.should == :article
+        end
+
+        it "sets the fields on the definition correctly" do
+          definition = Schema.find(:v1).definitions.first
+          definition.fields.length.should == 2
+          field = definition.fields.first
+          field.type.should == :string
+          field.name.should == :title
+        end
+      end
+
+      describe "with a multiple fields" do
+
+        it "adds one definition of the correct type article" do
+          schema = Schema.find(:v1)
+          schema.definitions.length.should == 1
+          definition = schema.definitions.first
+          definition.should be_kind_of(Definition)
+          definition.definition_name.should == :article
+        end
+
+        it "sets the fields on the definition correctly" do
+          definition = Schema.find(:v1).definitions.first
+          definition.fields.length.should == 2
+          field1 = definition.fields.first
+          field1.type.should == :string
+          field1.name.should == :title
+          field2 = definition.fields.last
+          field2.type.should == :has_many
+          field2.name.should == :comments
+        end
+      end
+    end
+    
+  end
+end

data/spec/active_api/simple_type_spec.rb

@@ -0,0 +1,13 @@
+require 'spec/spec_helper'
+
+module ActiveApi
+  describe SimpleType do
+
+    it "builds the node with the value" do
+      element = SimpleType.new "foo", :node => :bar
+      doc = element.build_xml.doc
+      doc.xpath("/bar").first.inner_text.should == "foo"
+    end
+
+  end
+end

data/spec/api_spec.rb

@@ -0,0 +1,343 @@
+require 'spec/spec_helper'
+
+module ActiveApi
+  describe "Defining a schema" do
+
+    describe "calling a collection from a schema" do
+      before do
+        @schema = Schema.version(:v1) do |xsl|
+          xsl.define :article do |t|
+            t.element :id, :string
+          end
+        end
+        @article = Article.new :id => 456
+      end
+
+      it "emits the string element" do
+        element = Schema.find(:v1).build_xml [@article], :node => :article
+        doc = element.doc
+        doc.xpath("/articles/article/id").inner_text.should == "456"
+      end
+    end
+
+    describe "with an element of type string" do
+      before do
+        @schema = Schema.version(:v1) do |xsl|
+          xsl.define :article do |t|
+            t.element :id, :string
+          end
+        end
+        @article = Article.new :id => 456
+      end
+
+      it "emits the string element" do
+        element = Collection.new [@article], :node => :article, :schema => @schema
+        doc = element.build_xml.doc
+        doc.xpath("/articles/article/id").inner_text.should == "456"
+      end
+    end
+
+    describe "with a string" do
+      before do
+        @schema = Schema.version(:v1) do |xsl|
+          xsl.define :article do |t|
+            t.string   :title
+          end
+        end
+        @article = Article.new :title => Faker::Company.bs
+      end
+
+      it "emits the string element" do
+        element = Collection.new [@article], :node => :article, :schema => @schema
+        doc = element.build_xml.doc
+        doc.xpath("/articles/article/title").first.inner_text.should == @article.title
+      end
+    end
+
+    describe "with an attribute of type string" do
+      before do
+        @schema = Schema.version(:v1) do |xsl|
+          xsl.define :article do |t|
+            t.attribute :id
+          end
+        end
+        @article = Article.new :id => 456
+      end
+
+      it "emits the string attribute" do
+        element = Collection.new [@article], :node => :article, :schema => @schema
+        doc = element.build_xml.doc
+        doc.xpath("/articles/article[@id=456]").should be
+      end
+    end
+
+    describe "with other data types" do
+      before do
+        @article = Article.new :published_on => Date.parse("3/5/1956")
+      end
+
+      it "emits the correctly formatted element" do
+        @schema = Schema.version(:v1) do |xsl|
+          xsl.define :article do |t|
+            t.date :published_on
+          end
+        end
+        element = Collection.new [@article], :node => :article, :schema => @schema
+        doc = element.build_xml.doc
+        doc.xpath("/articles/article/published_on").first.inner_text.should == "1956-03-05"
+      end
+
+      it "emits the correctly formatted element" do
+        @schema = Schema.version(:v1) do |xsl|
+          xsl.define :article do |t|
+            t.attribute :published_on, :type => :date
+          end
+        end
+        element = Collection.new [@article], :node => :article, :schema => @schema
+        doc = element.build_xml.doc
+        doc.xpath("/articles/article[@published_on=1956-03-05]").should be
+      end
+    end
+
+    describe "with a has_many element" do
+      before do
+        @schema = Schema.version(:v1) do |xsl|
+          xsl.define :article do |t|
+            t.has_many :comments
+          end
+        end
+
+        @article = Article.new :title => Faker::Company.bs
+        @comment = Comment.new :article => @article, :text => Faker::Company.bs
+        @article.comments = [@comment]
+      end
+
+      it "emits each of the child objects" do
+        @schema.define :comment do |t|
+          t.string :text
+        end
+
+        element = Collection.new [@article],
+                                          :node => :article,
+                                          :schema => @schema
+        doc = element.build_xml.doc
+        doc.xpath("/articles/article/comments/comment/text").first.inner_text.should == @comment.text
+      end
+    end
+
+    describe "with custom value procs" do
+      before do
+        @schema = Schema.version(:v1) do |xsl|
+          xsl.define :article do |t|
+            t.attribute :id, :value => proc {|attribute| "foo" }
+            t.string    :id, :value => proc {|element| "foo" }
+            t.has_many  :comments
+          end
+
+          xsl.define :comment do |t|
+            t.string      :article_title, :value => proc{|element| element.object.article.title }
+            t.belongs_to  :user
+          end
+
+          xsl.define :user do |t|
+            t.string :title, :value => proc{|element| element.parents[:article].title }
+          end
+        end
+
+        @article1 = Article.new :title => Faker::Company.bs
+        @article2 = Article.new :title => Faker::Lorem.sentence
+
+        @user = User.new
+        @comment1 = Comment.new :article => @article1, :user => @user
+        @comment2 = Comment.new :article => @article2, :user => @user
+
+        @article1.comments = [@comment1]
+        @article2.comments = [@comment2]
+      end
+
+      it "emits the value of the value proc for attributes" do
+        element = Collection.new [@article1],
+                                          :node => :article,
+                                          :schema => @schema
+        doc = element.build_xml.doc
+        doc.xpath("/articles/article[@id=foo]").should be
+      end
+
+      it "emits the value of the value proc for elements" do
+        element = Collection.new [@article1],
+                                          :node => :article,
+                                          :schema => @schema
+        doc = element.build_xml.doc
+        doc.xpath("/articles/article/id").first.inner_text.should == "foo"
+      end
+
+      it "emits the value of the value proc, which is passed an element containing a reference to the object" do
+        element = Collection.new [@article1],
+                                          :node => :article,
+                                          :schema => @schema
+        doc = element.build_xml.doc
+        doc.xpath("/articles/article/comments/comment/article_title").first.inner_text.should == @article1.title
+      end
+
+      it "emits the value of the value proc, which is passed an element containing a reference all ancestor objects" do
+        element = Collection.new [@article1, @article2],
+                                          :node => :article,
+                                          :schema => @schema
+        doc = element.build_xml.doc
+        doc.xpath("/articles/article").length.should == 2
+        doc.xpath("/articles/article/comments/comment/user/title").first.inner_text.should == @article1.title
+        doc.xpath("/articles/article/comments/comment/user/title").last.inner_text.should == @article2.title
+      end
+    end
+
+    describe "with belongs_to elements marked as choice" do
+      before do
+        @schema = Schema.version(:v1) do |xsl|
+          xsl.define :article do |t|
+            t.string :title
+          end
+
+          xsl.define :user do |t|
+            t.string :username
+          end
+
+          xsl.define :comment do |t|
+            t.belongs_to :commentable, :choice => {
+              "Article" => :article,
+              "User" => :user
+            }
+          end
+        end
+
+        @article = Article.new :title => Faker::Company.bs
+        @user = User.new :username => Faker::Internet.user_name
+        @comment1 = Comment.new :commentable => @article
+        @comment2 = Comment.new :commentable => @user
+        @comment3 = Comment.new :commentable => nil
+      end
+
+      it "uses the name of the class to lookup the definition to be used" do
+        element = Collection.new [@comment1, @comment2, @comment3], :node => :comment, :schema => @schema
+        doc = element.build_xml.doc
+        doc.xpath("/comments/comment").length.should == 3
+        doc.xpath("/comments/comment/article/title").inner_text.should == @article.title
+        doc.xpath("/comments/comment/user/username").inner_text.should == @user.username
+        doc.xpath("/comments/comment")[2].inner_text.should be_empty
+      end
+    end
+
+    describe "custom builders" do
+      before do
+        @schema = Schema.version(:v1) do |xsl|
+          xsl.define :article, :builder_class => "ActiveApi::MyCustomClass"
+        end
+
+        class MyCustomClass < ActiveApi::ComplexType
+          def build(builder)
+            builder.send :foo, :bar => "baz" do |xml|
+              xml.send :woot, "lol"
+            end
+          end
+        end
+
+        @article = Article.new :id => 456
+      end
+
+      it "uses the custom builder class" do
+        element = Schema.find(:v1).build_xml [@article], :node => :article
+        doc = element.doc
+        doc.xpath("/articles/foo[@bar='baz']/woot").first.inner_text.should == "lol"
+      end
+    end
+
+    describe "specifying a symbol as a value proc" do
+      before do
+        @schema = Schema.version(:v1) do |xsl|
+          xsl.define :article do |t|
+            t.string :foo, :value => :title
+          end
+        end
+
+        @article = Article.new :title => Faker::Company.bs
+      end
+
+      it "uses the custom builder class" do
+        element = Schema.find(:v1).build_xml [@article], :node => :article
+        doc = element.doc
+        doc.xpath("/articles/article/foo").first.inner_text.should == @article.title
+      end
+    end
+
+    describe "specifying a string literal as a value" do
+      before do
+        @schema = Schema.version(:v1) do |xsl|
+          xsl.define :article do |t|
+            t.string :foo, :value => "some value"
+          end
+        end
+
+        @article = Article.new :title => Faker::Company.bs
+      end
+
+      it "uses the custom builder class" do
+        element = Schema.find(:v1).build_xml [@article], :node => :article
+        doc = element.doc
+        doc.xpath("/articles/article/foo").first.inner_text.should == "some value"
+      end
+    end
+
+    describe "specifying custom definition classes with a string" do
+      before do
+        class MyDefinitionClass < Definition
+          def timestamps
+            date_time :created_at
+            date_time :updated_at
+          end
+        end
+
+        @schema = Schema.version(:v1, :definition_class => "ActiveApi::MyDefinitionClass") do |xsl|
+          xsl.define :article do |t|
+            t.timestamps
+          end
+        end
+
+        @article = Article.new :created_at => Date.parse("12/21/1945"), :updated_at => Date.parse("4/5/1992")
+      end
+
+      it "uses the custom builder class" do
+        element = Schema.find(:v1).build_xml [@article], :node => :article
+        doc = element.doc
+        doc.xpath("/articles/article/created_at").first.inner_text.should be_starts_with("1945-12-21")
+        doc.xpath("/articles/article/updated_at").first.inner_text.should be_starts_with("1992-04-05")
+      end
+    end
+
+    describe "specifying custom definition classes with a class" do
+      before do
+        class MyDefinitionClass < Definition
+          def timestamps
+            date_time :created_at
+            date_time :updated_at
+          end
+        end
+
+        @schema = Schema.version(:v1, :definition_class => MyDefinitionClass) do |xsl|
+          xsl.define :article do |t|
+            t.timestamps
+          end
+        end
+
+        @article = Article.new :created_at => Date.parse("12/21/1945"), :updated_at => Date.parse("4/5/1992")
+      end
+
+      it "uses the custom builder class" do
+        element = Schema.find(:v1).build_xml [@article], :node => :article
+        doc = element.doc
+        doc.xpath("/articles/article/created_at").first.inner_text.should be_starts_with("1945-12-21")
+        doc.xpath("/articles/article/updated_at").first.inner_text.should be_starts_with("1992-04-05")
+      end
+    end
+
+  end
+end
+

data/spec/domain.rb

@@ -0,0 +1,42 @@
+class ObjectHelper
+  class << self
+    def fields(*args)
+      args.each do |field|
+        field(field)
+      end
+    end
+
+    private
+
+    def field(field_name)
+      define_method field_name do
+        attributes[field_name]
+      end
+      define_method "#{field_name}=" do |value|
+        attributes[field_name] = value
+      end
+    end
+  end
+
+  attr_reader :attributes
+  def initialize(options = {})
+    @attributes = options
+  end
+
+end
+
+class Author < ObjectHelper
+  fields :id, :name
+end
+
+class Article < ObjectHelper
+  fields :id, :author, :title, :published_on, :comments, :created_at, :updated_at
+end
+
+class User < ObjectHelper
+  fields :id, :username
+end
+
+class Comment < ObjectHelper
+  fields :id, :article, :user, :text, :commentable
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'active_api'
+require 'faker'
+require 'rr'
+require 'domain'
+
+module SchemaHelper
+  def reset_schema
+    ActiveApi::Schema.reset_inheritable_attributes
+    ActiveApi::Schema.versions = []
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.mock_with :rr
+  config.include SchemaHelper
+  config.before(:each) { reset_schema }
+end