smg 0.0.1

data/README.rdoc

@@ -0,0 +1,28 @@
+== REQUIREMENTS:
+
+nokogiri (>=1.3)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009
+
+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/lib/smg/document.rb

@@ -0,0 +1,64 @@
+module SMG #:nodoc:
+  class Document < ::Nokogiri::XML::SAX::Document
+
+    attr_reader :object, :thing
+
+    def initialize(object, thing = nil)
+      @object   = object
+      @mapping  = object.class.mapping
+      @stack    = []
+      @docs     = []
+      @thing    = thing
+      @chars    = ""
+    end
+
+    def start_element(name, attrs = [])
+
+      @stack << name
+
+      if doc = @docs.last
+        doc.start_element(name, attrs)
+      elsif thing = @mapping.nested[@stack]
+        @docs << doc = Document.new(thing.data_class.new,thing)
+        doc.start_element(name, attrs)
+      end
+
+      if !attrs.empty? && maps = @mapping.attributes[@stack]
+        maps.values_at(*Hash[*attrs].keys).compact.each do |m|
+          ix = attrs.index(m.at)
+          @object.__send__(m.accessor, m.cast(attrs.at(ix+=1))) if ix
+        end
+      end
+
+      @element = @mapping.elements[@stack]
+      @chars = ""
+
+    end
+
+    def end_element(name)
+      @object.send(@element.accessor, @element.cast(@chars)) if @element && @chars
+      @chars, @element = nil, nil
+      if doc = @docs.last
+        doc.end_element(name)
+        if doc.thing.path == @stack
+          @object.__send__(doc.thing.accessor, doc.object)
+          @docs.pop
+        end
+      end
+      @stack.pop
+    end
+
+    def characters(string)
+      if doc = @docs.last
+        doc.characters(string)
+        @chars ||= ""
+        @chars << string
+      elsif @element
+        @chars << string
+      end
+    end
+
+  end
+end
+
+# EOF

data/lib/smg/mapping/element.rb

@@ -0,0 +1,48 @@
+module SMG #:nodoc:
+  class Mapping #:nodoc:
+
+    class Element
+      attr_reader :path, :name, :accessor, :data_class, :cast_to, :at
+
+      def initialize(path, options = {})
+
+        @name       = (options[:as] || options[:at] || path.last).to_sym
+        @path       = path
+        @collection = !!options[:collection]
+        @accessor   = @collection ? :"attach_#{@name}" : :"#{@name}="
+        @data_class = nil
+        @cast_to    = nil
+
+        if c = options[:class]
+          if Class === c
+            raise ArgumentError, "#{c} is not an SMG::Model" unless c.include?(::SMG::Resource)
+            @data_class = c
+          elsif Symbol === c
+            raise ArgumentError, "#{c} is not a valid typecast" unless TypeCasts.key?(c)
+            @cast_to = c
+          else
+            raise ArgumentError, ":class should be an SMG::Model or a Symbol"
+          end
+        end
+
+        #ignore :at on nested collections of resources
+        @at = options.key?(:at) && !@data_class ? options[:at].to_s : nil
+
+      end
+
+      def cast(value)
+        @cast_to ? ::SMG::Mapping::TypeCasts[@cast_to, value] : value
+      rescue
+        #TODO: report about malformed data
+      end
+
+      def collection?
+        @collection
+      end
+
+    end
+
+  end
+end
+
+# EOF

data/lib/smg/mapping/typecasts.rb

@@ -0,0 +1,37 @@
+require 'uri'
+require 'time'
+require 'date'
+
+module SMG #:nodoc:
+  class Mapping #:nodoc:
+    module TypeCasts
+
+      class << self
+        attr_accessor :typecasts
+
+        def [](key,value)
+          return typecasts[key][value] if typecasts.key?(key)
+          raise ArgumentError, "Can't typecast to #{key.inspect}"
+        end
+
+        def key?(key)
+          typecasts.key?(key)
+        end
+
+      end
+
+      # same as in extlib
+      self.typecasts = {}
+      self.typecasts[ :string   ] = lambda{ |v| v.to_s }
+      self.typecasts[ :integer  ] = lambda{ |v| v.to_i }
+      self.typecasts[ :boolean  ] = lambda{ |v| v.to_s.strip != 'false' }
+      self.typecasts[ :symbol   ] = lambda{ |v| v.to_sym }
+      self.typecasts[ :datetime ] = lambda{ |v| Time.parse(v).utc }
+      self.typecasts[ :date     ] = lambda{ |v| Date.parse(v) }
+      self.typecasts[ :uri      ] = lambda{ |v| ::URI.parse(v.to_s) }
+
+    end
+  end
+end
+
+# EOF

data/lib/smg/mapping.rb

@@ -0,0 +1,50 @@
+module SMG #:nodoc:
+  class Mapping
+
+    attr_reader :elements, :nested, :attributes
+    attr_reader :root
+
+    def initialize
+      @elements   = {}
+      @nested     = {}
+      @attributes = {}
+    end
+
+    def attach_element(tag,options)
+      chain = handle_path(tag)
+      if options.key?(:at)
+        ele = Element.new(chain, options)
+        @attributes[chain] ||= {}
+        @attributes[chain][ele.at] = ele
+      else
+        @elements[chain] = Element.new(chain, options)
+      end
+    end
+
+    def attach_nested(tag,options)
+      chain = handle_path(tag)
+      @nested[chain] = Element.new(chain, options.merge(:nested => true))
+    end
+
+    def use_root(path)
+      raise "root already defined!" if @root
+      @root = normalize_path(path)
+    end
+
+    private
+
+    def normalize_path(path)
+      path.to_s.split("/")
+    end
+
+    def handle_path(path)
+      ret = normalize_path(path)
+      ret.unshift(@root) if @root
+      ret.flatten!
+      ret
+    end
+
+  end
+end
+
+# EOF

data/lib/smg/model.rb

@@ -0,0 +1,57 @@
+module SMG #:nodoc:
+  module Model
+
+    def extract(tag, options = {})
+
+      thing = if Class === options[:class]
+        options.delete(:collection)
+        mapping.attach_nested(tag,options)
+      else
+        mapping.attach_element(tag,options)
+      end
+
+      attr_reader thing.name if (instance_methods & [thing.name, thing.name.to_s]).empty?
+      attr_writer thing.name if (instance_methods & [thing.accessor, thing.accessor.to_s]).empty?
+
+    end
+
+    def collect(tag, options = {})
+
+      options.merge!(:collection => true)
+      thing = Class === options[:class] ? mapping.attach_nested(tag,options) : mapping.attach_element(tag,options)
+
+      if (instance_methods & [thing.accessor, thing.accessor.to_s]).empty?
+        class_eval <<-CODE
+        def #{thing.accessor}(value)
+          @#{thing.name} ||= []
+          @#{thing.name} << value
+        end
+        CODE
+      end
+
+      if (instance_methods & [thing.name, thing.name.to_s]).empty?
+        class_eval <<-CODE
+        def #{thing.name}
+          @#{thing.name} ||= []
+        end
+        CODE
+      end
+
+    end
+
+    def root(tag)
+      mapping.use_root(tag)
+    end
+
+    def parse(xml)
+      self.new.parse(xml)
+    end
+
+    def mapping
+      @mapping ||= Mapping.new
+    end
+
+  end
+end
+
+# EOF

data/lib/smg/resource.rb

@@ -0,0 +1,17 @@
+module SMG #:nodoc:
+  module Resource
+
+    def self.included(base)
+      base.extend Model
+    end
+
+    def parse(data)
+      doc = SMG::Document.new(self)
+      ::Nokogiri::XML::SAX::Parser.new(doc).parse(data)
+      self
+    end
+
+  end
+end
+
+# EOF

data/lib/smg/version.rb

@@ -0,0 +1,5 @@
+module SMG
+  VERSION = '0.0.1'
+end
+
+# EOF

data/lib/smg.rb

@@ -0,0 +1,14 @@
+require 'pathname'
+require 'rubygems'
+
+gem 'nokogiri', '>=1.3'
+require 'nokogiri'
+
+require 'smg/mapping/element'
+require 'smg/mapping/typecasts'
+require 'smg/mapping'
+require 'smg/model'
+require 'smg/resource'
+require 'smg/document'
+
+# EOF

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: smg
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- SSDany
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-16 00:00:00 +04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        version: "1.3"
+  type: :runtime
+  version_requirements: *id001
+description: Simple declaratibve XML parsing library. Backed by Nokogiri
+email: inadsence@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- lib/smg/document.rb
+- lib/smg/mapping/element.rb
+- lib/smg/mapping/typecasts.rb
+- lib/smg/mapping.rb
+- lib/smg/model.rb
+- lib/smg/resource.rb
+- lib/smg/version.rb
+- lib/smg.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: smg
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Simple declaratibve XML parsing library. Backed by Nokogiri
+test_files: []
+