ostructer 0.1

data/History.rdoc

@@ -0,0 +1,3 @@
+=== 0.1 / 2011-09-11
+
+* Everything is new. First release

data/Manifest.txt

@@ -0,0 +1,5 @@
+History.rdoc
+Manifest.txt
+README.rdoc
+Rakefile
+lib/ostructer.rb

data/README.rdoc

@@ -0,0 +1,17 @@
+= Ostructer - Open Struct Builder in Ruby
+
+* http://github.com/geraldb/ostructer
+
+== DESCRIPTION:
+
+Lets you build open structs from nested hashes, arrays and strings.
+
+== INSTALL:
+
+Just install the gem:
+
+  $ sudo gem install ostructer
+
+== LICENSE:
+
+The ostructers sources are dedicated to the public domain. Use it as you please with no restrictions whatsoever.

data/Rakefile

@@ -0,0 +1,23 @@
+require 'hoe'
+require './lib/ostructer.rb'
+
+Hoe.spec 'ostructer' do
+  
+  self.version = Ostructer::VERSION
+  
+  self.summary = 'Ostructer - Open Struct Builder'
+  self.url     = 'http://github.com/geraldb/ostructer'
+  
+  self.author  = 'Gerald Bauer'
+  self.email   = 'gerald.bauer@gmail.com'
+  
+  self.extra_deps = [
+    ['xml-simple','>= 1.1.0']
+  ]
+  
+  self.remote_rdoc_dir = 'doc'
+  
+  # switch extension to .rdoc for gihub formatting
+  self.readme_file  = 'README.rdoc'
+  self.history_file = 'History.rdoc'
+end

data/lib/ostructer.rb

@@ -0,0 +1,353 @@
+
+require 'forwardable'
+require 'cgi'
+
+module Ostructer
+
+  VERSION = '0.1'
+
+## todo: use blank slate/basic object (no id? no type?)
+#
+# undef id and type (possible?)
+# class OpenStruct
+#    undef id # deprecated in Ruby 1.8; removed in 1.9
+#    undef type # same thing
+#  end 
+
+#
+#
+# folded elements (e.g. element with no attributes just content) get returned as string, thus,
+#
+# to_bool
+# to_date
+# to_xml    will not be available!!!!! (unless added to String class)
+#
+# check if to_date exists? in ruby standard
+
+#
+#  NB: key.first -> different with Rails or without (without results in more than one letter!!)
+
+class OsBase    # base for OsArray/OsOpenStruct/OsOpenStructNil
+
+  attr :logger            # read-only
+  attr_accessor :parent   # read,write
+  attr_accessor :field    # read,write
+
+  def full_dot_path
+    path = "#{@field}"
+    node = @parent
+
+    ## NOTE: assume if parent == nil openstruct is root node    
+    while node && node.parent
+      # logger.debug "node.class: #{node.class}, node.field: #{node.field}"  
+      if node.is_a?( OsArray )
+        path = "#{node.field}" + path
+      else
+        path = "#{node.field}." + path
+      end
+      node = node.parent      
+    end
+    path
+  end
+
+end  # class OsBase
+
+
+class OsValue < OsBase
+
+  # holds/wraps a string
+
+  def initialize( value, logger )
+    @value   = value
+    @logger  = logger
+    
+    @parent  = nil
+    @field   ="[!unknown_value]"
+  end
+
+  def to_openstruct_pass2
+    # do nothing (has no children)
+  end
+
+  include Comparable
+    
+  def <=>(other)
+    if other.is_a? Numeric
+      logger.debug "OsValue <=> Numeric:  #{self.to_i} <=> #{other}"
+      self.to_i <=> other      
+    elsif other.is_a? String
+      logger.debug "OsValue <=> String:  #{self.to_s} <=> #{other}"
+      self.to_s <=> other
+    else
+      logger.debug "OsValue - no <=> defined for type #{other.class}" 
+      nil           
+    end
+    
+    ## todo: add bool
+  end
+
+  def to_s
+    @value
+  end
+  
+  def to_i
+    @value.to_i
+  end
+
+  def to_bool
+    @value == 'true'
+  end
+
+
+end # class OsValue
+
+
+class OsArray < OsBase
+  extend Forwardable
+
+  include Enumerable
+      
+  def_delegators :@ary, :each, :[], :size   
+                    
+  def initialize( ary, logger )
+    @ary    = ary
+    @logger = logger
+    
+    @parent = nil
+    @field  = "[!unknown_array]"
+  end
+  
+  def to_openstruct_pass2
+    self.each_with_index do | el, index |
+      if el.is_a?( OsOpenStruct ) || el.is_a?( OsArray ) || el.is_a?( OsValue )
+        el.field  = "[#{index}]"
+        el.parent = self
+      end
+      el.to_openstruct_pass2
+    end
+  end
+  
+end  # class OsArray
+
+
+
+class OsOpenStructNil < OsBase
+    
+  def initialize( parent, field, logger )
+    @parent = parent
+    @field  = "!#{field}"  # mark missing field with starting ! (exclamation mark)
+    @logger = logger
+  end 
+  
+  def nil?
+    logger.debug "calling OsNil#nil?"
+    true
+  end
+  
+  def to_s
+    logger.debug "calling OsNil#to_s"
+    nil
+  end
+  
+  def to_i
+    logger.debug "calling OsNil#to_i"
+    nil
+  end
+
+  def to_date
+    logger.debug "calling OsNil#to_date"
+    nil
+  end
+
+  def to_bool
+    logger.debug "calling OsNil#to_bool"
+    nil
+  end
+
+
+  def method_missing(mn,*a) 
+    ## NEW: added; add to org
+    mn = mn.to_s
+     
+    logger.warn "OsOpenStructNil - feld '#{mn}' nicht gefunden using path '#{full_dot_path}'; returning OsOpenStructNil"
+    OsOpenStructNil.new( self, mn, logger )
+  end
+
+end   # end class OsOpenStructNil
+
+
+
+class OsOpenStruct < OsBase
+
+  def initialize( hash_in, logger )
+    @parent = nil
+    @field  = "[!unknown_hash]"
+
+    @logger = logger
+    @hash = {}
+ 
+    ## fix: can we change the hash-in-place?? don't create a new one
+    
+    # todo: add hook for normalize keys  (downcase first letter, strip packages, etc.)    
+    hash_in.each do |key,value|
+      # downcase first letter (e.g. Address to address)
+      key = key[0...1].downcase + key[1..-1]
+
+      @hash[ key ] = value  
+    end
+  end
+
+  def to_openstruct_pass2   # link up: set parent and field    
+    @hash.each do |key,value|
+      if value.is_a?( OsOpenStruct ) || value.is_a?( OsArray ) || value.is_a?( OsValue )
+        value.field  = key.to_s
+        value.parent = self
+      end
+      value.to_openstruct_pass2
+    end    
+    # logger.debug "after MyOpenStruct#to_openstruct_pass2  parent=#{parent.nil? ? 'nil' : parent.object_id}, field=#{field}" 
+  end
+  
+  def has_key?( key )
+    # NOTE: use has_key? instead of nil? to avoid warnings in log that are expected if fields are missing
+    @hash.has_key?( key.to_s )
+  end
+  
+  def fetch( key, default = nil )
+    @hash.fetch( key, default)
+  end
+  
+  include Comparable
+    
+  def <=>(other)
+    
+    ## fix: check if struct has short-cut value (e.g. text); short-cut value might not exist
+    ## fix/todo: add bool
+    
+    if other.is_a? Numeric
+      logger.debug "OsOpenStruct <=> Numeric:  #{self.to_i} <=> #{other}"
+      self.to_i <=> other      
+    elsif other.is_a? String
+      logger.debug "OsOpenStruct <=> String:  #{self.to_s} <=> #{other}"
+      self.to_s <=> other
+    else
+      logger.debug "OsOpenStruct - no <=> defined for type #{other.class}" 
+      nil           
+    end    
+  end
+
+  def method_missing(mn,*a)
+ 
+    mn = mn.to_s
+     
+    ## convenience property for boolean check
+    if mn[-1].chr == "?" 
+      mn = mn[0..-2]  # cut of trailing ?      
+      if @hash.has_key?(mn)               
+        value = @hash.fetch( mn ).fetch( 'text' )
+        
+        logger.debug "OsOpenStruct - boolean feld '#{mn}' with value '#{value}' returns #{value=='1'}"
+                
+        return value == "1"  # return
+      else
+        logger.warn "OsOpenStruct - boolean feld '#{mn}' nicht gefunden in Hash using path '#{full_dot_path}'; returning OsOpenStructNil"
+        OsOpenStructNil.new( self, mn+"?", logger )  # return
+      end        
+    else       
+     if @hash.has_key?(mn)
+       @hash[mn]
+     else
+       logger.warn "OsOpenStruct - feld '#{mn}' nicht gefunden in Hash using path '#{full_dot_path}'; returning OsOpenStructNil"
+       ## pp self
+       OsOpenStructNil.new( self, mn, logger )
+     end
+    end
+  end
+    
+  
+  def to_xml
+    logger.debug "calling OsOpenStruct#to_xml"
+    ## todo: check if CGI module is included
+    ## todo: use another unescape method for xml entities??
+    CGI.unescapeHTML( internal_value )    
+  end
+    
+  def to_s
+    # puts "[DEBUG] calling OsOpenStruct#to_s"
+    value = internal_value
+    value.nil? ? nil : value.to_s
+  end
+  
+  def to_i
+    # puts "[DEBUG] calling OsOpenStruct#to_i"
+    value = internal_value
+    value.nil? ? nil : value.to_i
+  end
+
+  def to_date
+    logger.debug "calling MyOpenStruct#to_date"
+    internal_value     # format to date required for sqlite
+  end
+
+  def to_bool
+    ## todo: how to handle no value exists? return false or nil?
+    # puts "[DEBUG] calling MyOpenStruct#to_bool"
+    internal_value == 'true'
+  end
+  
+private
+   def internal_value
+    if @hash.has_key?('text')
+      value = @hash.fetch( 'text' )      
+      return value       
+    else
+      logger.warn "feld 'text' nicht gefunden (called internal_value())"
+      return nil
+    end          
+  end
+  
+end # class OsOpenStruct
+
+
+end  # module Ostructer
+
+
+################################
+##
+## extensions to core/built-in classes (Object, Array, Hash)
+##
+
+class Object
+  def to_openstruct( logger )
+    
+    # pass 1: construct data structure using new classes (OsArray, OsOpenStruct, OsValue) 
+    # convert Array  to OsArray
+    # convert Hash   to OsOpenStruct
+    # convert String to OsValue
+        
+    newself = self.to_openstruct_pass1( logger )    
+    newself.to_openstruct_pass2         # pass 2: link up parents (reverse link)
+    newself
+  end
+end
+
+class String
+  def to_openstruct_pass1( logger )
+    Ostructer::OsValue.new( self, logger )
+  end  
+end
+
+class Array
+  def to_openstruct_pass1( logger )
+    mapped = map{ |el| el.to_openstruct_pass1( logger ) }
+    Ostructer::OsArray.new( mapped, logger )
+  end
+end
+
+class Hash
+  def to_openstruct_pass1( logger )
+    mapped = {}
+    each{ |key,value | mapped[key.to_s] = value.to_openstruct_pass1( logger ) }
+    Ostructer::OsOpenStruct.new( mapped, logger )
+  end
+end

data/test/test_config.rb

@@ -0,0 +1,69 @@
+require 'test/unit'
+require 'logger'
+require 'pp'
+
+require 'rubygems'
+require 'xmlsimple'
+
+# LIB_PATH = File.expand_path( File.dirname( 'lib' ) )
+# $LOAD_PATH.unshift(LIB_PATH)
+
+require 'lib/ostructer.rb'
+
+## notes:
+##  add note about faster_xml_simple (drop-in replacement for xml_in only using libxml)
+
+## todo: check if root is simple root if forceArray is true!!
+
+#   NB: ContentKey text only added if at least one attribute present!!
+#    otherwise value is used-as-is in place (not as a hash)
+#   use ForceContent => true options to force creation of hash
+#
+#
+#
+
+class TestConfig < Test::Unit::TestCase
+  
+  def setup
+    fn   = 'test/config.xml'
+    opts = { 'ContentKey' => 'text',
+             'ForceArray' => false,
+             'ForceContent' => true,
+             'KeepRoot' => true } 
+      
+    @doc = XmlSimple.xml_in( fn, opts )
+    
+    # puts "=== xmlsimple:"    
+    # pp @doc
+    
+    logger = Logger.new(STDOUT)
+    logger.level = Logger::DEBUG
+  
+    @doc = @doc.to_openstruct( logger )
+    
+    ## puts "=== ostructer:"    
+    ## pp @doc
+  end
+  
+  def test_readers    
+    assert_equal( 'sahara', @doc.config.server[0].name.to_s )    # attribute
+    assert_equal( '10.0.0.101', @doc.config.server[0].address[0].text.to_s )   # contentKey   
+    assert_equal( '10.0.0.101', @doc.config.server[0].address[0].to_s )        # contentKey shortcut (no .text)
+    assert( '.text shortcut String <=>', @doc.config.server[0].address[0] == '10.0.0.101' )
+  end
+  
+  def test_full_dot_path
+    assert_equal( 'config.logdir', @doc.config.logdir.full_dot_path )
+    assert_equal( 'config.server', @doc.config.server.full_dot_path )
+    assert_equal( 'config.server[0]', @doc.config.server[0].full_dot_path )
+    assert_equal( 'config.server[0].name', @doc.config.server[0].name.full_dot_path )
+    assert_equal( 'config.server[0].address', @doc.config.server[0].address.full_dot_path )
+    assert_equal( 'config.server[0].address[0]', @doc.config.server[0].address[0].full_dot_path )
+    assert_equal( 'config.server[0].address[0].text', @doc.config.server[0].address[0].text.full_dot_path )
+  end
+  
+  def test_missing
+    assert_equal( '!one.!two.!three',  @doc.one.two.three.full_dot_path )
+  end
+    
+end # class TestConfig

data/test/test_customer.rb

@@ -0,0 +1,63 @@
+require 'test/unit'
+require 'logger'
+require 'pp'
+
+require 'rubygems'
+require 'xmlsimple'
+
+# LIB_PATH = File.expand_path( File.dirname( 'lib' ) )
+# $LOAD_PATH.unshift(LIB_PATH)
+
+require 'lib/ostructer.rb'
+
+## NB: XmlSimple -> ForceArray is true by default (turn it off!!)
+##
+
+class TestCustomer < Test::Unit::TestCase
+  
+  def setup
+    fn   = 'test/customer.xml'
+    opts = { 'ContentKey' => 'text',
+             'ForceArray' => false,
+             'ForceContent' => true } 
+     
+    @customer = XmlSimple.xml_in( fn, opts )
+    
+    puts "=== xmlsimple:"    
+    pp @customer
+    
+    logger = Logger.new(STDOUT)
+    logger.level = Logger::DEBUG
+  
+    @customer = @customer.to_openstruct( logger )
+    
+    # puts "=== ostructer:"    
+    # pp @customer
+  end
+  
+  def test_readers
+    assert_equal( 'home', @customer.address[0].typ.to_s )    # attribute
+    assert_equal( 'Joe', @customer.first_name.text.to_s )
+    assert_equal( 'Joe', @customer.first_name.to_s )          # short-cut (.text)
+  end
+  
+  
+end # class TestCustomer
+
+
+## from the XmlSimple docs
+#
+#  Elements which only contain text content will simply be represented as a scalar.
+#  Where an element has both attributes and text content, the element will be represented
+#    as a hash with the text content in the 'content' key:
+#
+#    <opt>
+#      <one>first</one>
+#      <two attr="value">second</two>
+#    </opt>
+#
+#    {
+#      'one' => 'first',
+#      'two' => { 'attr' => 'value', 'content' => 'second' }
+#    }
+#

data/test/test_misc.rb

@@ -0,0 +1,40 @@
+require 'logger'
+require 'pp'
+
+require 'rubygems'
+require 'xmlsimple'
+
+# LIB_PATH = File.expand_path( File.dirname( 'lib' ) )
+# $LOAD_PATH.unshift(LIB_PATH)
+
+require 'lib/ostructer.rb'
+
+  
+def test_keep_root
+  fn   = 'test/config.xml'
+  opts = { 'ContentKey' => 'text',
+             'ForceArray' => false,
+             'ForceContent' => true,
+             'KeepRoot' => true } 
+      
+  doc = XmlSimple.xml_in( fn, opts )
+    
+  puts "=== xmlsimple:"    
+  pp doc
+end
+
+def test_parse_status
+  fn   = 'test/status.xml'
+  opts = { 'ContentKey' => 'text',
+             'ForceArray' => false } 
+      
+  statuses = XmlSimple.xml_in( fn, opts )
+    
+  puts "=== xmlsimple:"    
+  pp statuses  
+end
+
+if __FILE__ == $0  
+  # test_keep_root()
+  test_parse_status()
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification 
+name: ostructer
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Gerald Bauer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-11 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: xml-simple
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 1
+        - 0
+        version: 1.1.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 0
+        - 4
+        version: 2.0.4
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 2
+        - 6
+        - 1
+        version: 2.6.1
+  type: :development
+  version_requirements: *id003
+description: Lets you build open structs from nested hashes, arrays and strings.
+email: gerald.bauer@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- Manifest.txt
+files: 
+- History.rdoc
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- lib/ostructer.rb
+- test/test_customer.rb
+- test/test_config.rb
+- test/test_misc.rb
+has_rdoc: true
+homepage: http://github.com/geraldb/ostructer
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: ostructer
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ostructer - Open Struct Builder
+test_files: 
+- test/test_customer.rb
+- test/test_config.rb
+- test/test_misc.rb