sunstone 0.1.0

data/lib/sunstone/exception.rb

@@ -0,0 +1,43 @@
+module Sunstone
+  
+  class RecordInvalid < ::Exception
+  end
+  
+  class RecordNotSaved < ::Exception
+  end
+  
+  class Exception < ::Exception
+    
+    class UnexpectedResponse < Sunstone::Exception
+    end
+
+    class BadRequest < Sunstone::Exception
+      attr_reader :response
+      def initialize(response)
+        super
+        @response = response
+      end
+    end
+
+    class Unauthorized < Sunstone::Exception
+    end
+
+    class NotFound < Sunstone::Exception
+    end
+
+    class Gone < Sunstone::Exception
+    end
+
+    class MovedPermanently < Sunstone::Exception
+    end
+
+    class ApiVersionUnsupported < Sunstone::Exception
+    end
+
+    class ServiceUnavailable < Sunstone::Exception
+    end
+
+  end
+  
+end
+

data/lib/sunstone/model.rb

@@ -0,0 +1,23 @@
+require 'sunstone/model/attributes'
+require 'sunstone/model/associations'
+require 'sunstone/model/persistence'
+
+module Sunstone
+  class Model
+    
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+    
+    include Sunstone::Model::Attributes
+    include Sunstone::Model::Associations
+    include Sunstone::Model::Persistence
+    
+    def initialize(attrs={})
+      super
+      attrs.each do |k, v|
+        self.send(:"#{k}=", v)
+      end
+    end
+    
+  end
+end

data/lib/sunstone/model/associations.rb

@@ -0,0 +1,89 @@
+module Sunstone
+  class Model
+    
+    module Associations
+      
+      extend ActiveSupport::Concern
+      
+      attr_accessor :assoications
+      
+      def initialize(*)
+        super
+        @associations = {}
+      end
+      
+      def reflect_on_associations
+        self.class.reflect_on_associations
+      end
+      
+      module ClassMethods
+        
+        def inherited(subclass)
+          super
+          subclass.initialize_associations
+        end
+  
+        def initialize_associations
+          @associations = {}
+        end
+  
+        def reflect_on_associations
+          @associations
+        end
+        
+        def belongs_to(name, options = {})
+          @associations[name] = {
+            :name => name,
+            :macro => :belongs_to,
+            :klass => (options[:class_name] || name).to_s.camelize.constantize,
+            :foreign_key => (options[:foreign_key] || :"#{name}_id")
+          }
+          
+          attribute(@associations[name][:foreign_key], :integer)
+          define_association_reader(@associations[name])
+          define_association_writer(@associations[name])
+        end
+        
+        def has_many(name, options = {})
+          @associations[name] = {
+            :name => name,
+            :macro => :has_many,
+            :klass => (options[:class_name] || name.to_s.singularize).to_s.camelize.constantize
+          }
+          
+          define_association_reader(@associations[name])
+          define_association_writer(@associations[name])
+        end
+  
+        def define_association_reader(association)
+          # if association[:macro] == :belongs_to
+            class_eval <<-EOV, __FILE__, __LINE__ + 1
+              def #{association[:name]}
+                @associations[:#{association[:name]}]
+              end
+            EOV
+          # end
+        end
+  
+        def define_association_writer(association)
+          if association[:macro] == :belongs_to
+            class_eval <<-EOV, __FILE__, __LINE__ + 1
+              def #{association[:name]}=(value)
+                self.#{association[:foreign_key]} = value.id if !value.nil?
+                @associations[:#{association[:name]}] = value
+              end
+            EOV
+          elsif association[:macro] == :has_many
+            class_eval <<-EOV, __FILE__, __LINE__ + 1
+              def #{association[:name]}=(value)
+                @associations[:#{association[:name]}] = value
+              end
+            EOV
+          end
+        end
+
+      end
+      
+    end
+  end
+end

data/lib/sunstone/model/attributes.rb

@@ -0,0 +1,99 @@
+module Sunstone
+  class Model
+    
+    class SchemaDefiner
+  
+      attr_reader :defined_attributes
+  
+      def initialize(schema)
+        @schema = schema
+        @defined_attributes = []
+      end
+  
+      def attribute(name, type, options = {})
+        @schema.attribute(name, type, options)
+        @defined_attributes << name
+      end
+  
+      Sunstone::Type::Value.subclasses.each do |type|
+        class_eval <<-EOV, __FILE__, __LINE__ + 1
+          def #{type.name.demodulize.downcase}(name, options = {})
+            attribute(name, "#{type.name.demodulize.downcase}", options)
+          end
+        EOV
+      end
+  
+    end
+    
+    module Attributes
+      
+      extend ActiveSupport::Concern
+      
+      attr_accessor :attributes
+      
+      def initialize(*)
+        @attributes = {}
+      end
+      
+      def schema
+        self.class.schema
+      end
+      
+      def has?(attribute)
+        !!@attributes[attribute]
+      end
+      
+      module ClassMethods
+        
+        def inherited(subclass)
+          super
+          subclass.initialize_schema
+        end
+  
+        def initialize_schema
+          @schema = Sunstone::Schema.new
+          attribute(:id, :integer)
+        end
+  
+        def schema
+          @schema
+        end
+        
+        def define_schema(&block)
+          definer = SchemaDefiner.new(@schema)
+          definer.instance_eval(&block)
+    
+          definer.defined_attributes.each do |name|
+            define_attribute_reader(name, @schema[name])
+            define_attribute_writer(name, @schema[name])
+          end
+        end
+  
+        def attribute(name, type, options = {})
+          attribute = @schema.attribute(name, type, options)
+    
+          define_attribute_reader(name, attribute)
+          define_attribute_writer(name, attribute)
+        end
+  
+        def define_attribute_reader(name, type)
+          class_eval <<-EOV, __FILE__, __LINE__ + 1
+            def #{name}
+              @attributes[:#{name}]
+            end
+          EOV
+        end
+  
+        def define_attribute_writer(name, type)
+          class_eval <<-EOV, __FILE__, __LINE__ + 1
+            def #{name}=(value)
+              @attributes[:#{name}] = schema[:#{name}].type_cast_from_user(value)
+            end
+          EOV
+        end
+
+      end
+      
+    end
+  end
+end

data/lib/sunstone/model/persistence.rb

@@ -0,0 +1,168 @@
+class Wankel::SaxEncoder
+  
+  def value(val)
+    if val.is_a?(Numeric)
+      number(val)
+    elsif val.is_a?(String)
+      string(val)
+    elsif val.nil?
+      null
+    elsif val == true || val == false
+      boolean(val)
+    elsif val.is_a?(Array)
+      array_open
+      val.each {|v| value(v) }
+      array_close
+    else
+      puts 'fail'
+    end
+  end
+  
+end
+
+module Sunstone
+  class Model
+    
+    module Persistence
+      
+      extend ActiveSupport::Concern
+      
+      def initialize(*)
+        super
+        @new_record = true
+      end
+      
+      # Returns true if this object hasn't been saved yet -- that is, a record
+      # for the object doesn't exist in the database yet; otherwise, returns false.
+      def new_record?
+        @new_record
+      end
+
+      # Returns true if this object has been destroyed, otherwise returns false.      
+      def destroyed?
+        @destroyed
+      end
+          
+      # Returns true if the record is persisted, i.e. it's not a new record and
+      # it was not destroyed, otherwise returns false.
+      def persisted?
+        !(new_record? || destroyed?)
+      end
+      
+      def serialize(options={})
+        attrs = options[:only] || schema.attributes.keys
+        
+        output = StringIO.new
+        encoder = Wankel::SaxEncoder.new(output)
+        
+        encoder.map_open
+        
+        attrs.each do |name|
+          encoder.string  name
+          encoder.value   schema[name].type_cast_for_json(self.send(name))
+        end
+        
+        encoder.map_close
+        encoder.complete
+        output.string
+      end
+      
+      def serialize_for_create_and_update
+        attrs = []
+        schema.attributes.each do |name, type|
+          attrs << name if name != "id" && !type.readonly?
+        end
+      
+        serialize(:only => attrs)
+      end
+      
+      # Saves the model.
+      #
+      # If the model is new a record gets created, otherwise the existing record
+      # gets updated.
+      #
+      # TODO:
+      # By default, save always run validations. If any of them fail the action
+      # is cancelled and +save+ returns +false+. However, if you supply
+      # validate: false, validations are bypassed altogether. See
+      # ActiveRecord::Validations for more information.
+      #
+      # TODO:
+      # There's a series of callbacks associated with +save+. If any of the
+      # <tt>before_*</tt> callbacks return +false+ the action is cancelled and
+      # +save+ returns +false+. See ActiveRecord::Callbacks for further
+      # details.
+      #
+      # Attributes marked as readonly are silently ignored if the record is
+      # being updated.
+      def save(*)
+        create_or_update
+      rescue Sunstone::RecordInvalid
+        false
+      end
+
+      # Saves the model.
+      #
+      # If the model is new a record gets created, otherwise the existing record
+      # gets updated.
+      #
+      # TODO:
+      # With <tt>save!</tt> validations always run. If any of them fail
+      # ActiveRecord::RecordInvalid gets raised. See ActiveRecord::Validations
+      # for more information.
+      #
+      # TODO:
+      # There's a series of callbacks associated with <tt>save!</tt>. If any of
+      # the <tt>before_*</tt> callbacks return +false+ the action is cancelled
+      # and <tt>save!</tt> raises ActiveRecord::RecordNotSaved. See
+      # ActiveRecord::Callbacks for further details.
+      #
+      # Attributes marked as readonly are silently ignored if the record is
+      # being updated.
+      def save!(*)
+        create_or_update || raise(RecordNotSaved)
+      end
+      
+      private
+      
+      def create_or_update
+        result = new_record? ? _create_record : _update_record
+        result != false
+      end
+      
+      def _create_record
+        begin
+          Sunstone.post("/#{self.class.model_name.route_key}", serialize_for_create_and_update) do |response|
+            Sunstone::Parser.parse(self, response)
+          end
+          @new_record = false
+          true
+        rescue Sunstone::Exception::BadRequest => e
+          Sunstone::Parser.parse(self, e.response)
+          raise Sunstone::RecordInvalid
+        end
+      end
+      
+      def _update_record
+        Sunstone.put("/#{self.class.model_name.route_key}/#{self.to_param}", serialize_for_create_and_update) do |response|
+          Sunstone::Parser.parse(self, response)
+        end
+      end
+      
+      module ClassMethods
+      
+        def find(id)
+          Sunstone.get("/#{self.model_name.route_key}/#{id}") do |response|
+            model = Sunstone::Parser.parse(self, response)
+            model.instance_variable_set(:@new_record, false)
+            model
+          end
+        end
+      
+      end
+
+      
+    end
+    
+  end
+end

data/lib/sunstone/parser.rb

@@ -0,0 +1,93 @@
+module Sunstone
+  class Parser < Wankel::SaxParser
+    
+    attr_reader :object
+    
+    def self.parse(instance_or_class, response_or_body)
+      parser = self.new(instance_or_class)
+      
+      if response_or_body.is_a?(Net::HTTPResponse)
+        response_or_body.read_body do |chunk|
+          parser << chunk
+        end
+      else
+        parser << response_or_body
+      end
+      
+      parser.complete
+    end
+  
+    def initialize(klass, options=nil)
+      super(options)
+      
+      @object = klass.class == Class ? klass.new : klass
+      @stack = []
+    end
+
+    def on_map_start
+      if @stack.size == 0
+        @stack << @object
+      elsif @stack.last.is_a?(Array)
+        key = @stack[-2].to_sym
+        if @stack[-3].reflect_on_associations[key]
+          @stack << @stack[-3].reflect_on_associations[key][:klass].new
+        end
+      else
+        key = @stack.last.to_sym
+        if @stack[-2].reflect_on_associations[key]
+          @stack << @stack[-2].reflect_on_associations[key][:klass].new
+        end
+      end
+    end
+  
+    def on_map_end
+      value = @stack.pop
+      
+      on_value(value) if @stack.size > 0
+      
+      value
+    end
+  
+    def on_map_key(key)
+      @stack << key
+    end
+  
+    def on_value(value)
+      if @stack.last.is_a?(Array)
+        @stack.last << value
+      else
+        attribute = @stack.pop
+        @stack.last.send(:"#{attribute}=", value) if @stack.last.respond_to?(:"#{attribute}=")
+      end
+    end
+  
+    def on_null; on_value(nil) ;end
+    alias :on_boolean :on_value
+    alias :on_integer :on_value
+    alias :on_double  :on_value
+    alias :on_string  :on_value
+  
+    def on_array_start
+        @stack << Array.new
+    end
+  
+    def on_array_end
+      value = @stack.pop
+      attribute = @stack.pop
+      @stack.last.send(:"#{attribute}=", value) if @stack.last.respond_to?(:"#{attribute}=")
+    end
+  
+    # Override to return the account
+    def parse(*args, &block)
+      super(*args, &block)
+      @object
+    end
+  
+    # Override to return the account
+    def complete
+      super
+      @object
+    end
+    
+  end
+end