clinth3o-acdc 0.1.0 → 0.1.1

data/lib/acdc/attribute.rb

@@ -0,0 +1,20 @@
+module AcDc
+  
+  # Attribute object used in Element and Body.
+  # Not often used outside of these.
+  class Attribute
+    
+    attr_accessor :name, :value
+    
+    def initialize(name,value)
+      @name = name
+      @value = value
+    end
+    
+    # Returns the values of this attribute in hash form
+    def to_hash
+      {@name => @value}
+    end
+    
+  end
+end

data/lib/acdc/body.rb

@@ -0,0 +1,165 @@
+module AcDc
+  class Body 
+    
+    attr_accessor :attributes, :elements
+    
+    # Populates the attributes and elements declared for this object.
+    #@option values [Hash] :attributes Hash list of attributes to populate
+    #@example Filling the values and attributes
+    # class ThunderStruck < Body
+    #   attribute :thunder
+    #   element :lightning
+    # end
+    # kaboom = ThunderStruck.new({:attributes => {:thunder => "boom"}, :lightning => "crash"})
+    def initialize(values = {})
+      @attributes ||= {}
+      @elements ||= {}
+      # catch default values for attributes
+      unless self.class.declared_attributes.values.all?{|val| val.nil?}
+        self.class.declared_attributes.each do |key,val|
+          attributes.update(key => Attribute(key,val)) unless val.nil?
+        end
+      end
+      # now set initialized attribute values
+      if values.has_key?(:attributes)
+        values.delete(:attributes).each do |key,val|
+          if self.class.declared_attributes.has_key?(key)
+            attributes.update(key => Attribute(key,val)) 
+          end
+        end
+      end
+      # and finally set values
+      values.each do |key,val|
+        if self.class.declared_elements.has_key?(key)
+          type = options_for(key)[:type]
+          if type
+            if val.respond_to?(:each)
+              val.each {|v| raise ArgumentError.new("Type is invalid") unless v.is_a?(type)}
+            else
+              raise ArgumentError.new("Type is invalid") unless val.is_a?(type)
+            end
+            elements.update(key => type.new(val,options_for(key),key))
+          else
+            elements.update(key => Element(val,options_for(key),key))
+          end
+        end
+      end
+    end
+    
+    # Converts object to XML
+    def acdc
+      xml = Builder::XmlMarkup.new
+      attrs = attributes.inject({}){|acc,attr| acc.update(attr[1].to_hash)}
+      xml.tag!(tag_name,attrs){ |body|
+        elements.each do |key, elem|
+          body << elem.acdc
+        end
+      }
+      xml.target!
+    end
+    
+    # The name to use for the tag
+    def tag_name
+      self.class.to_s.split("::").last
+    end
+    
+    def method_missing(method_id, *args, &block)
+      key = method_id.to_s.gsub(/\=/,"").to_sym
+      if elements.has_key?(key) or attributes.has_key?(key)
+        (method_id.to_s.match(/\=$/)) ? write(method_id, *args, &block) : read(method_id)
+      else
+        super
+      end
+    end
+
+    class << self
+      def inherited(child)
+        child.instance_variable_set('@elements',@elements ||= {})
+        child.instance_variable_set('@attributes',@attributes ||= {})
+      end
+      
+      # Declare an Element for this Body
+      #@param [Symbol] name A name to assign the Element (tag name)
+      #@param [Class] type A type to use for the element (enforcement)
+      #@option options [Boolean] :single False if object is a collection
+      def element(*options)
+        @elements ||= {}
+        name = options.first
+        type = options.second || nil
+        opts = options.extract_options!
+        @elements.update(name => opts.merge(:type => type))
+      end
+      
+      # Declare an attribute for this Body
+      def attribute(name, value = nil)
+        @attributes ||= {}
+        @attributes.update(name => value)
+      end
+      
+      # Returns the Hash list of Elements declared
+      def declared_elements 
+        @elements
+      end
+      
+      # Returns a Hash list of Attributes declared
+      def declared_attributes 
+        @attributes
+      end
+      
+      # Converts the XML to a Class object found in the library
+      def acdc(xml)
+        doc = Hpricot.XML(xml)
+        klass = doc.root.name.constantize
+        attributes = doc.root.attributes.inject({}){|acc,attr| acc.update(attr[0].to_sym => attr[1])}
+        values = doc.root.children.inject({}) do |acc, node|
+          name = node.name.underscore.to_sym
+          value = value_from_node(node)
+          attrs = node.attributes
+          acc.merge!({name => value, :attributes => attrs})
+        end
+        klass.new(values.merge(:attributes => attributes))
+      end
+      
+      private
+        def value_from_node(node)
+          if node.respond_to?(:children) and node.children
+            values = node.children.collect do |child|
+              return child.inner_text if child.text?
+              instantiate(child)
+            end      
+            (values.size == 1) ? values.first : values    
+          end
+        end
+      
+        def instantiate(node)
+          name = node.name
+          attrs = node.attributes
+          klass = name.constantize
+          klass.new(value_from_node(node), :attributes => attrs)
+        end
+    end
+    
+    private
+      def options_for(key)
+        self.class.declared_elements[key]
+      end
+      
+      def read(method_id)
+        if elements.has_key?(method_id)
+          elements[method_id].value
+        else
+          attributes[method_id].value
+        end
+      end
+    
+      def write(method_id, *args, &block)
+        key = method_id.to_s.gsub(/\=$/,"").to_sym
+        if elements.has_key?(key)
+          elements.update(key => Element(args.first,options_for(key),key))
+        else
+          attributes.update(key => Attribute(key,args.first))
+        end
+      end
+
+  end
+end

data/lib/acdc/element.rb

@@ -0,0 +1,73 @@
+module AcDc
+  
+  # Basic XML Element
+  class Element
+    
+    attr_accessor :value, :tag, :attributes, :options
+    
+    # Constructor with the following:
+    #@param [Object] value Any value to place in the tags
+    #@option options [Boolean] :single False if object is a collection 
+    #@param [String] tag A tag name to use if not Element
+    def initialize(value, options={}, tag=nil)
+      @tag = tag ||= self.class.to_s.split("::").last
+      @value = value
+      @options = options
+      @attributes = options.delete(:attributes)
+    end
+    
+    # Converts the object to XML
+    def acdc
+      xml = Builder::XmlMarkup.new
+      if value.nil?
+        xml.tag!(tag_content)
+      else
+        has_many? ? render_many(xml) : xml.tag!(tag_content) {|elem| elem << content}
+      end
+      xml.target!
+    end
+    
+    # True if object has a collection of values
+    def has_many?
+      options.has_key?(:single) and !options[:single] and value.size > 1
+    end
+    
+    # The name to use for the tag
+    def tag_name
+      tag.to_s.camelize
+    end
+    
+    # Overridden to compare the values and not the whole object
+    def eql?(other)
+      return false if other.nil?
+      return false unless other.kind_of?(self.class)
+      value.eql?(other.value)
+    end
+    
+    private
+      def tag_content
+        (attributes.nil? or attributes.empty?) ? tag_name : [tag_name,attributes]
+      end
+      
+      def content
+        if has_many?
+          value.inject(""){|xml,val| xml << (val.is_a?(Element) ? val.acdc : val.to_s)}
+        else
+          value.is_a?(Element) ? value.acdc : value.to_s
+        end
+      end
+      
+      def render_many(xml)
+        if value.respond_to?(:each)
+          xml.tag!(tag_content){|elem|
+            value.each{|val| 
+              raise Exception.new("Can't render non-Element multiple times.") unless val.respond_to?(:acdc)
+              elem << val.acdc
+            }
+          }
+        else
+          xml.tag!(tag_content) {|elem| elem << content}
+        end
+      end
+  end
+end

data/lib/acdc.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'builder'
+require 'activesupport'
+require 'hpricot'
+                                          
+require File.join(File.dirname(__FILE__),"acdc","attribute")
+require File.join(File.dirname(__FILE__),"acdc","element")
+require File.join(File.dirname(__FILE__),"acdc","body")
+
+module AcDc
+  
+  VERSION = [0,1,1] unless defined?(AcDc::VERSION)
+  
+  if defined?(JAIL_BREAK)
+    Element.class_eval{ alias :to_s :acdc }
+    Body.class_eval{ alias :to_s :acdc }
+  end
+  
+end
+
+include AcDc
+
+# Will construct a AcDc::Element classs
+def Element(value, options = {}, name = nil)
+  Element.new(value,options,name)
+end
+
+# Will construct a AcDc::Attribute class
+def Attribute(name,value)
+  Attribute.new(name,value)
+end
+
+# Will convert the XML to a class found in the library
+def acdc(xml)
+  Body.acdc(xml)
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: clinth3o-acdc
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - Clint Hill
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-16 00:00:00 -07:00
+date: 2009-09-19 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: 2.3.2
     version: 
 - !ruby/object:Gem::Dependency 
   name: builder
@@ -30,7 +30,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: 2.1.2
     version: 
 - !ruby/object:Gem::Dependency 
   name: hpricot
@@ -40,7 +40,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: "0.8"
     version: 
 description: This is a little xml-to-object-to-xml library that gets Dirty Deeds Done Dirt Cheap.
 email: clint.hill@h3osoftware.com
@@ -54,8 +54,12 @@ files:
 - LICENSE
 - README
 - Rakefile
+- lib/acdc.rb
+- lib/acdc/attribute.rb
+- lib/acdc/body.rb
+- lib/acdc/element.rb
 has_rdoc: false
-homepage: http://h3osoftware.com/acdc
+homepage: http://github.com/clinth3o/acdc
 licenses: 
 post_install_message: 
 rdoc_options: []
@@ -76,10 +80,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: acdc
+rubyforge_project: 
 rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
-summary: AC/DC by h3o(software)
+specification_version: 3
+summary: This is a little xml-to-object-to-xml library that gets Dirty Deeds Done Dirt Cheap.
 test_files: []