active_api 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,7 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+.idea
+junk*

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Jeff Dean
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,174 @@
+= ActiveApi
+
+ActiveApi allows you to define an XML schema in Ruby, and use that schema to convert ruby objects to xml.
+
+== Theory
+
+I think that exposing your data via XML is not the job of the model.  Instead, it's the job of a class (or classes) that is specifically designed to translate your model schema into a schema appropriate for public consumption.
+
+A good api tool will have built-in support for:
+
+* XSD or DTD generation
+* Versioning
+* The ability to represent your model in a way that is not tightly coupled to the model itself
+
+ActiveApi attempts to do this.
+
+== Usage
+
+You define a schema like so:
+
+    Schema.version(:v1) do |schema|
+      schema.define :article do |t|
+        t.attribute :id
+        t.string    :title
+        t.date      :published_on
+        t.has_many  :comments
+      end
+
+      schema.define :comment do |t|
+        t.belongs_to  :user
+        t.string      :article_title, :value => proc{|element|
+          element.object.article.title
+        }
+      end
+
+      schema.define :user do |t|
+        t.string :username, :value => :user_name
+      end
+    end
+
+To create xml from this schema:
+
+    @v1 = ActiveApi::Schema.find(:v1)
+    @element = @v1.build_xml [@article1, @article2], :node => :article
+    @element.to_xml
+
+Which will give you xml output that looks like this:
+
+    <?xml version="1.0"?>
+    <articles>
+      <article id="1">
+        <title>target efficient applications</title>
+        <published_on>2004-08-22</published_on>
+        <comments>
+          <comment>
+            <article_title>target efficient applications</article_title>
+            <user>
+              <username>foo</username>
+            </user>
+          </comment>
+        </comments>
+      </article>
+      <article id="2">
+        <title>recontextualize viral e-services</title>
+        <published_on>2004-12-05</published_on>
+        <comments>
+          <comment>
+            <article_title>recontextualize viral e-services</article_title>
+            <user>
+              <username>foo</username>
+            </user>
+          </comment>
+        </comments>
+      </article>
+    </articles>
+
+== Extending
+
+ActiveApi is highly extensible.  The general pattern used to extend ActiveApi is to subclass the default ActiveApi implementation, and specify that you'd like to use your subclass instead.
+
+For example, if you are working with a database that has audit columns such as timestamps, you might want to do this:
+
+    class MyDefinitionClass < ActiveApi::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
+
+    Schema.find(:v1).build_xml [@article], :node => :article
+
+Which will produce the following xml:
+
+    <?xml version="1.0"?>
+    <articles>
+      <article>
+        <created_at>1945-12-21T00:00:00+00:00</created_at>
+        <updated_at>1992-04-05T00:00:00+00:00</updated_at>
+      </article>
+    </articles>
+
+NOTE: when specifying custom definition classes, those classes must be loaded before calling Schema.version
+
+You can also create custom classes for any element you define, like so:
+
+    @schema = Schema.version(:v1) do |xsl|
+      xsl.define :article, :builder_class => "MyCustomClass"
+    end
+
+    class MyCustomClass < ActiveApi::ComplexType
+      def build(builder)
+        builder.send :foo, :bar => "baz" do |xml|
+          xml.send :woot, "lol"
+        end
+      end
+    end
+
+    Schema.find(:v1).build_xml [@article], :node => :article
+
+Which will produce the following xml:
+
+    <?xml version="1.0"?>
+    <articles>
+      <foo bar="baz">
+        <woot>lol</woot>
+      </foo>
+    </articles>
+
+NOTE: since the builder classes are evaluated at runtime, you can specify a string name for the class, and the class does _not_ have to be loaded before calling Schema.version
+
+== Features
+
+You define your schema completely separately from your data.  So you could in theory render multiple types of objects with the same schema, provided that they have the same interface.  You could also render a single object in any number of ways.
+
+You can choose to have the builder send methods on your object, or provide more complex values by using the :value => proc{} syntax.
+
+The element keeps track of all of it's ancestors, so you can emit certain elements conditionally based on what has come before them.
+
+The Schema definition just creates an array of Ruby objects, which you could use to create documentation.
+
+You define your schema versions using whatever versioning scheme you want - could be a string, symbol or any other object.  You can render the same objects with different schemas easily. This library is totally agnostic as to how or if you version your schemas.
+
+The schema defining DSL allows you to define any valid XSL data format.
+
+== Implementation
+
+ActiveApi uses's Nokogori::XML::Builder to create the xml nodes.  As such, the creation of the xml is fast.  The rest of the code likely needs major refactoring to be performant and have a small footprint with large datasets.
+
+== Authors
+
+While I (Jeff Dean) wrote all of the code in this repo, the code was inspired by pairing on a similar project with:
+
+* Mike Dalessio
+* Peter Jaros
+
+== Development
+
+The basic idea here is to create a DSL that can provide:
+
+* A valid xml schema that you can link to and distribute
+* A means to document your code
+* A bunch of useful, time-saving ways to easily translate your model to a consumable xml document
+
+See the issue tracker on github for a complete list.
+
+== Copyright
+
+Copyright (c) 2009 Jeff Dean. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "active_api"
+    gem.summary = %Q{An api layer for ruby}
+    gem.email = "jeff@zilkey.com"
+    gem.homepage = "http://github.com/zilkey/active_api"
+    gem.authors = ["Jeff Dean"]
+    gem.add_dependency('nokogiri', '>= 1.3.2')
+    gem.add_dependency('activesupport', '>= 2.3.2')
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "active_api #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/active_api.gemspec

@@ -0,0 +1,73 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{active_api}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jeff Dean"]
+  s.date = %q{2009-07-05}
+  s.email = %q{jeff@zilkey.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "active_api.gemspec",
+     "geminstaller.yml",
+     "lib/active_api.rb",
+     "lib/active_api/builder.rb",
+     "lib/active_api/collection.rb",
+     "lib/active_api/complex_type.rb",
+     "lib/active_api/definition.rb",
+     "lib/active_api/field.rb",
+     "lib/active_api/has_definition.rb",
+     "lib/active_api/schema.rb",
+     "lib/active_api/simple_type.rb",
+     "spec/active_api/complex_type_spec.rb",
+     "spec/active_api/definition_spec.rb",
+     "spec/active_api/field_spec.rb",
+     "spec/active_api/schema_spec.rb",
+     "spec/active_api/simple_type_spec.rb",
+     "spec/api_spec.rb",
+     "spec/domain.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/zilkey/active_api}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.3}
+  s.summary = %q{An api layer for ruby}
+  s.test_files = [
+    "spec/active_api/complex_type_spec.rb",
+     "spec/active_api/definition_spec.rb",
+     "spec/active_api/field_spec.rb",
+     "spec/active_api/schema_spec.rb",
+     "spec/active_api/simple_type_spec.rb",
+     "spec/api_spec.rb",
+     "spec/domain.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<nokogiri>, [">= 1.3.2"])
+      s.add_runtime_dependency(%q<activesupport>, [">= 2.3.2"])
+    else
+      s.add_dependency(%q<nokogiri>, [">= 1.3.2"])
+      s.add_dependency(%q<activesupport>, [">= 2.3.2"])
+    end
+  else
+    s.add_dependency(%q<nokogiri>, [">= 1.3.2"])
+    s.add_dependency(%q<activesupport>, [">= 2.3.2"])
+  end
+end

data/geminstaller.yml

@@ -0,0 +1,15 @@
+---
+defaults:
+  install_options: --source=http://gems.github.com --source=http://gems.rubyforge.org --include-dependencies --no-ri --no-rdoc
+gems:
+- name: rr
+  version: 0.8.1
+- name: activesupport
+  version: 2.3.2
+- name: rspec
+  version: 1.2.7
+- name: nokogiri
+  version: 1.3.2
+- name: faker
+  version: 0.3.1
+

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/lib/active_api/builder.rb

@@ -0,0 +1,11 @@
+module ActiveApi
+  module Builder
+
+    def build_xml(builder = Nokogiri::XML::Builder.new)
+      builder.tap do |xml|
+        build(xml)
+      end
+    end
+
+  end
+end

data/lib/active_api/collection.rb

@@ -0,0 +1,30 @@
+module ActiveApi
+  class Collection
+    include Builder
+    include HasDefinition
+
+    attr_reader :objects, :node, :parents, :schema
+
+    def initialize(objects, options)
+      @objects  = objects
+      @node     = options[:node]
+      @parents  = options[:parents]
+      @schema   = options[:schema]
+    end
+
+    protected
+
+    def build(builder)
+      builder.send "#{node.to_s.pluralize}_" do |xml|
+        objects.each do |object|
+          element = definition.builder_class.constantize.new object,
+                                                             :node => node,
+                                                             :parents => parents,
+                                                             :schema => schema
+          element.build_xml(xml)
+        end
+      end
+    end
+
+  end
+end

data/lib/active_api/complex_type.rb

@@ -0,0 +1,58 @@
+module ActiveApi
+  class ComplexType
+    include Builder
+    include HasDefinition
+
+    attr_reader :object, :node, :parents, :schema
+
+    def initialize(object, options = {})
+      @object = object
+      @node   = options[:node]
+      @parents = options[:parents] || {}
+      @parents[node.to_s.singularize.to_sym] = object
+      @schema = options[:schema]
+    end
+
+    protected
+
+    def build(builder)
+      builder.send "#{node.to_s.singularize}_", attributes do |xml|
+        definition.elements.each do |field|
+          name = field.name_for(object)
+          if name.present?
+            element = field.klass.new value(field),
+                                      :node => name,
+                                      :parents => parents,
+                                      :format => field.type,
+                                      :schema => schema
+            element.build_xml(xml)
+          end
+        end
+      end
+    end
+
+    def attributes
+      {}.tap do |attributes|
+        definition.attributes.each do |field|
+          name = field.name_for(object)
+          attribute = SimpleType.new value(field),
+                                     :node => name,
+                                     :format => field.type
+          attribute.append(attributes)
+        end
+      end
+    end
+
+    def value(field)
+      if field.value.nil?
+        object.send(field.name)
+      elsif field.value.is_a?(Symbol)
+        object.send(field.value)
+      elsif field.value.is_a?(String)
+        field.value
+      else
+        field.value.call(self)
+      end
+    end
+  end
+end