active_api 0.1.0

data/lib/active_api/definition.rb

@@ -0,0 +1,74 @@
+module ActiveApi
+  class Definition
+    attr_reader :definition_name, :fields, :builder_class
+
+    def initialize(options)
+      @definition_name  = options[:definition_name]
+      @builder_class    = options[:builder_class] || ComplexType.to_s
+      @fields           = options[:fields] || []
+    end
+
+    def attribute(name, type = :string, options = {})
+      field options.merge(:name => name, :type => type, :field_type => :attribute)
+    end
+
+    def element(name, type = :string, options = {})
+      send type, name, options
+    end
+
+    SimpleType.formats.each do |hash|
+      hash.each do |standard_name, xml_name|
+        define_method standard_name do |name, *options|
+          options = options.first || {}
+          field options.merge(:name => name, :type => standard_name, :klass => SimpleType)
+        end
+
+        if standard_name != xml_name
+          define_method xml_name do |name, *options|
+            options = options.first || {}
+            field options.merge(:name => name, :type => standard_name, :klass => SimpleType)
+          end
+        end
+      end
+    end
+
+    def belongs_to(name, options = {})
+      field options.merge(:name => name, :type => :belongs_to, :klass => ComplexType)
+    end
+
+    def has_one(name, options = {})
+      field options.merge(:name => name, :type => :has_one, :klass => ComplexType)
+    end
+
+    def has_many(name, options = {})
+      field options.merge(:name => name, :type => :has_many, :klass => Collection)
+    end
+
+    def attributes
+      fields.select do |field|
+        field.field_type == :attribute
+      end
+    end
+
+    def elements
+      fields.select do |field|
+        field.field_type == :element
+      end
+    end
+
+    def singular_name
+      name.to_s.singularize
+    end
+
+    def plural_name
+      name.to_s.pluralize
+    end
+
+    private
+
+    def field(options)
+      self.fields << Field.new(options)
+    end
+    
+  end
+end

data/lib/active_api/field.rb

@@ -0,0 +1,25 @@
+module ActiveApi
+  class Field
+    attr_reader :type, :name, :klass, :value, :choice, :field_type
+
+    def initialize(options = {})
+      @type         = options[:type]
+      @name         = options[:name]
+      @klass        = options[:klass]
+      @value        = options[:value]
+      @choice       = options[:choice]
+      @field_type   = options[:field_type] || :element
+    end
+
+    def name_for(object)
+      if choice
+        value = object.send(name)
+        return nil if value.nil?
+        return choice[value.class.to_s]
+      else
+        name
+      end
+    end
+
+  end
+end

data/lib/active_api/has_definition.rb

@@ -0,0 +1,9 @@
+module ActiveApi
+  module HasDefinition
+    def definition
+      schema.definitions.detect do |definition|
+        definition.definition_name == node.to_s.singularize.to_sym
+      end
+    end
+  end
+end

data/lib/active_api/schema.rb

@@ -0,0 +1,39 @@
+module ActiveApi
+
+  class Schema
+    class_inheritable_array :versions
+
+    class << self
+      def version(version, options = {})
+        options[:definition_class] ||= Definition
+        schema = Schema.new version, options
+        yield schema
+        write_inheritable_array :versions, [schema]
+        schema
+      end
+
+      def find(version)
+        versions.detect { |schema| schema.version == version }
+      end
+    end
+
+    attr_reader :version, :definitions, :definition_class
+    def initialize(version, options = {})
+      @version     = version
+      @definitions = []
+      @definition_class = options[:definition_class]
+    end
+
+    def define(name, options = {})
+      options[:definition_name] = name
+      definition = definition_class.to_s.constantize.new options
+      yield definition if block_given?
+      definitions << definition
+    end
+
+    def build_xml(objects, options)
+      Collection.new(objects, options.merge(:schema => self)).build_xml
+    end
+
+  end
+end

data/lib/active_api/simple_type.rb

@@ -0,0 +1,103 @@
+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
+      return nil if text.blank?
+      (self.class.format_procs[format] || self.class.default_format_proc).call(text)
+    end
+
+  end
+end

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,367 @@
+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 nil when the value is nil" do
+        @schema = Schema.version(:v1) do |xsl|
+          xsl.define :article do |t|
+            t.date :published_on
+          end
+        end
+        @article.published_on = nil
+        element = Collection.new [@article], :node => :article, :schema => @schema
+        doc = element.build_xml.doc
+        doc.xpath("/articles/article/published_on").first.inner_text.should == ""
+      end
+
+      it "emits the correctly formatted attribute" 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
+
+      it "emits nil when the attribute value is nil" do
+        @schema = Schema.version(:v1) do |xsl|
+          xsl.define :article do |t|
+            t.attribute :published_on, :type => :date
+          end
+        end
+        @article.published_on = nil
+        element = Collection.new [@article], :node => :article, :schema => @schema
+        doc = element.build_xml.doc
+        doc.xpath("/articles/article[@published_on='']").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
+