jordi-xml_struct 0.2.1 → 0.9.0

data/xml_struct.gemspec

@@ -0,0 +1,38 @@
+Gem::Specification.new do |s|
+  s.name        = 'xml_struct'
+  s.version     = '0.9.0'
+  s.date        = '2008-10-13'
+
+  s.author      = 'Jordi Bunster'
+  s.email       = 'jordi@bunster.org'
+  s.homepage    = 'http://github.com/jordi/xml_struct'
+
+  s.add_dependency 'activesupport'
+
+  s.summary     = "The Rubyista's way to do quick XML sit-ups"
+  s.description = %{ This is a library for reading (not writing) XML. It is
+                     particularly suited for cases where one is dealing with
+                     small documents of a known structure.
+
+                     It is slow and not devoid of caveats, but has a very
+                     pleasant, Ruby-like syntax. }.strip!.gsub! /\s+/, ' '
+
+  s.files = %w[ MIT-LICENSE
+                README.rdoc
+                TODO
+                WHATSNEW
+                lib
+                lib/jordi-xml_struct.rb
+                lib/xml_struct
+                lib/xml_struct/adapters
+                lib/xml_struct/adapters/hpricot.rb
+                lib/xml_struct/adapters/rexml.rb
+                lib/xml_struct/array_notation.rb
+                lib/xml_struct/blankish_slate.rb
+                lib/xml_struct/collection_proxy.rb
+                lib/xml_struct/default_adapter.rb
+                lib/xml_struct/method_missing_dispatchers.rb
+                lib/xml_struct/string.rb
+                lib/xml_struct.rb
+                xml_struct.gemspec ]
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jordi-xml_struct
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
+  version: 0.9.0
 platform: ruby
 authors: 
 - Jordi Bunster
@@ -19,7 +19,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 2.1.1
+        version: "0"
     version: 
 description: This is a library for reading (not writing) XML. It is particularly suited for cases where one is dealing with small documents of a known structure. It is slow and not devoid of caveats, but has a very pleasant, Ruby-like syntax.
 email: jordi@bunster.org
@@ -27,28 +27,32 @@ executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- README.markdown
+extra_rdoc_files: []
+
 files: 
 - MIT-LICENSE
-- README.markdown
-- Rakefile
+- README.rdoc
 - TODO
 - WHATSNEW
 - lib
 - lib/jordi-xml_struct.rb
 - lib/xml_struct
+- lib/xml_struct/adapters
+- lib/xml_struct/adapters/hpricot.rb
+- lib/xml_struct/adapters/rexml.rb
+- lib/xml_struct/array_notation.rb
 - lib/xml_struct/blankish_slate.rb
 - lib/xml_struct/collection_proxy.rb
-- lib/xml_struct/common_behaviours.rb
+- lib/xml_struct/default_adapter.rb
+- lib/xml_struct/method_missing_dispatchers.rb
 - lib/xml_struct/string.rb
 - lib/xml_struct.rb
-has_rdoc: true
+- xml_struct.gemspec
+has_rdoc: false
 homepage: http://github.com/jordi/xml_struct
 post_install_message: 
-rdoc_options: 
-- --main
-- README.markdown
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -70,41 +74,5 @@ rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: The Rubyista's way to do quick XML sit-ups
-test_files: 
-- test
-- test/samples
-- test/samples/lorem.xml
-- test/samples/recipe.xml
-- test/samples/weird_characters.xml
-- test/test_helper.rb
-- test/vendor
-- test/vendor/test-spec
-- test/vendor/test-spec/bin
-- test/vendor/test-spec/bin/specrb
-- test/vendor/test-spec/examples
-- test/vendor/test-spec/examples/stack.rb
-- test/vendor/test-spec/examples/stack_spec.rb
-- test/vendor/test-spec/lib
-- test/vendor/test-spec/lib/test
-- test/vendor/test-spec/lib/test/spec
-- test/vendor/test-spec/lib/test/spec/dox.rb
-- test/vendor/test-spec/lib/test/spec/rdox.rb
-- test/vendor/test-spec/lib/test/spec/should-output.rb
-- test/vendor/test-spec/lib/test/spec/version.rb
-- test/vendor/test-spec/lib/test/spec.rb
-- test/vendor/test-spec/Rakefile
-- test/vendor/test-spec/README
-- test/vendor/test-spec/ROADMAP
-- test/vendor/test-spec/SPECS
-- test/vendor/test-spec/test
-- test/vendor/test-spec/test/spec_dox.rb
-- test/vendor/test-spec/test/spec_flexmock.rb
-- test/vendor/test-spec/test/spec_mocha.rb
-- test/vendor/test-spec/test/spec_nestedcontexts.rb
-- test/vendor/test-spec/test/spec_new_style.rb
-- test/vendor/test-spec/test/spec_should-output.rb
-- test/vendor/test-spec/test/spec_testspec.rb
-- test/vendor/test-spec/test/spec_testspec_order.rb
-- test/vendor/test-spec/test/test_testunit.rb
-- test/vendor/test-spec/TODO
-- test/xml_struct_test.rb
+test_files: []
+

data/README.markdown

@@ -1,151 +0,0 @@
-# XML Struct
-
-(This is inspired by Python's `xml_objectify`)
-
-  XML Struct attempts to make accessing small, well-formed XML structures
-convenient, by using dot notation (`foo.bar`) to represent both attributes
-and child elements whenever possible.
-
-  XML parsing libraries (in general) have interfaces that are useful when
-one is using XML for its intended purpose, but cumbersome when one always
-sends the same XML structure, and always process all of it in the same
-way. This one aims to be a bit different.
-
-## Example usage
-
-    <recipe name="bread" prep_time="5 mins" cook_time="3 hours">
-      <title>Basic bread</title>
-      <ingredient amount="8" unit="dL">Flour</ingredient>
-      <ingredient amount="10" unit="grams">Yeast</ingredient>
-      <ingredient amount="4" unit="dL" state="warm">Water</ingredient>
-      <ingredient amount="1" unit="teaspoon">Salt</ingredient>
-      <instructions easy="yes" hard="false">
-        <step>Mix all ingredients together.</step>
-        <step>Knead thoroughly.</step>
-        <step>Cover with a cloth, and leave for one hour in warm room.</step>
-        <step>Knead again.</step>
-        <step>Place in a bread baking tin.</step>
-        <step>Cover with a cloth, and leave for one hour in warm room.</step>
-        <step>Bake in the oven at 180(degrees)C for 30 minutes.</step>
-      </instructions>
-    </recipe>
-
-    require 'xml_struct'
-    recipe = XMLStruct.new io_with_recipe_xml_shown_above
-
-    recipe.name                      => "bread"
-    recipe.title                     => "Basic bread"
-
-    recipe.ingredients.is_a?(Array)  => true
-    recipe.ingredients.first.amount  => "8" # Not a Fixnum. Too hard. :(
-
-    recipe.instructions.easy?        => true
-
-    recipe.instructions.first.upcase => "MIX ALL INGREDIENTS TOGETHER."
-    recipe.instructions.steps.size   => 7
-
-## Installation instructions
-
-    sudo gem install jordi-xml_struct --source http://gems.github.com
-
-## Motivation
-
-  XML is an **extensible** markup language. It is extensible because it is
-meant to define markup languages for **any** type of document, so new tags
-are needed depending on the problem domain.
-
-  Sometimes, however, XML ends up being used to solve a much simpler problem:
-the issue of passing a data-structure over the network, and/or between two
-different languages. Tools like JSON or YAML are a much better fit for
-this kind of job, but one doesn't always have that luxury.
-
-## Caveats
-
-  The dot notation is used as follows. For the given file:
-
-    <outer id="root" name="foo">
-      <name>Outer Element</name>
-    </outer>
-
-  `outer.name` is the `<name>` element. Child elements are always looked up
-first, then attributes. To access the attribute in the case of ambiguity,
-use `outer[:attr => 'name']`.
-
-  `outer.id` is really `Object#id`, because all of the object methods are
-preserved (this is on purpose). To access the attribute `id`, use
-`outer[:attr => 'id']`, or `outer['id']` since there's no element/attribute
-ambiguity.
-
-## Features & Problems
-
-### Collection auto-folding
-
-  Similar to XML::Simple, XML Struct folds same named elements at the same
-level. For example:
-
-    <student>
-      <name>Bob</name>
-      <course>Math</course>
-      <course>Biology</course>
-    </student>
-
-    student = XMLStruct.new(xml_file)
-
-    student.course.is_a? Array       => true
-    student.course.first == 'Math'   => true
-    student.course.last  == 'Biology => true
-
-### Collection pluralization:
-
-  With the same file from the `Collection auto-folding` section above, you
-also get this (courtesy of `ActiveSupport`'s `Inflector`):
-
-    student.courses.first == student.course.first => true
-
-### Collection proxy
-
-  Sometimes, collections are expressed with a container element in XML:
-
-    <student>
-      <name>Bob</name>
-      <courses>
-        <course>Math</course>
-        <course>Biology</course>
-      </courses>
-    </student>
-
-  In this case, since the container element `courses` has no text element
-of its own, and it only has elements of one name under it, it delegates
-all methods it doesn't contain to the collection below, so you get:
-
-    student.courses.collect { |c| c.downcase.to_sym } => [:math, :biology]
-
-### Question mark notation
-
-  Strings that look like booleans are "booleanized" if called by their
-question mark names (such as `enabled?`)
-
-### Slow
-
-So far, XML Struct uses REXML to do the actual XML parsing. Support
-for using faster parsers is planned, leaving REXML as a fallback option.
-
-### Recursive
-
-The entire XML file is parsed using REXML right now, and then converted to
-an XMLStruct of XMLStruct objects recursively. Deep files are bound to
-throw `SystemStackError`, but for the kinds of files I need to read, things
-are working fine so far. In any case, stream parsing is on the TODO list.
-
-### Incomplete
-
-It most likely doesn't work with a ton of features of complex XML files. I
-will always try to accomodate those, as long as they don't make the basic
-usage more complex. As usual, patches welcome.
-
-## Legal
-
-Copyright (c) 2008 Jordi Bunster, released under the MIT license
-
-
-

data/Rakefile

@@ -1,36 +0,0 @@
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-
-desc 'Default: run unit tests.'
-task :default => :test
-
-desc 'Run the unit tests.'
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
-end
-
-desc 'Generate documentation'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'XMLStruct'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include 'README.markdown'
-  rdoc.rdoc_files.include 'lib/**/*.rb'
-end
-
-desc 'Measures test coverage using rcov'
-task :rcov do
-  rm_f 'coverage'
-  rm_f 'coverage.data'
-
-  rcov = %{ rcov --aggregate coverage.data --text-summary
-    --include lib
-    --exclude /Library/Ruby
-  }.strip!.gsub! /\s+/, ' '
-
-  system("#{rcov} --html #{Dir.glob('test/**/*_test.rb').join(' ')}")
-  system('open coverage/index.html') if PLATFORM['darwin']
-end

data/lib/xml_struct/common_behaviours.rb

@@ -1,53 +0,0 @@
-module XMLStruct::CommonBehaviours
-
-  # Detect an existing method being called in question form:
-  def __question_answer(method, *args, &block)
-    if method.to_s.match(/\?$/) && args.empty? && block.nil?
-      boolish = __send__(method.to_s.chomp('?').to_sym).to_s
-
-      return true  if %w[ true yes t y ].include? boolish.downcase
-      return false if %w[ false no f n ].include? boolish.downcase
-    end
-  end
-
-  # Array-notation access to elements and attributes. It comes handy when
-  # the element or attribute you need to reach is not reachable via dot
-  # notation (because it's not a valid method name, or because the method
-  # exists, such as 'id' or 'class').
-  #
-  # It also supports hash keys, which are useful to reach attributes named
-  # the same as elements in the same level (which otherwise go first)
-  #
-  # All of this is a lot easier to exampling by example:
-  #
-  #   <article id="main_article" author="j-random">
-  #     <author>J. Random Hacker</author>
-  #   </article>
-  #
-  #   article.id                 => 9314390         # Object#id gets called
-  #   article[:id]               => "main_article"  # id attribute
-  #   article[:author]           => <XMLStruct ...> # <author> element
-  #   article[:attr => 'author'] => "j-random"      # author attribute
-  #
-  # Valid keys for the hash notation in the example above are :attr,
-  # :attribute, :child, and :element.
-  def [](name)
-    return @__target[name] if @__target && name.is_a?(Numeric)
-
-    unless name.is_a? Hash
-      return @__children[name.to_sym]   if @__children[name.to_sym]
-      return @__attributes[name.to_sym] if @__attributes[name.to_sym]
-    end
-
-    raise 'one and only one key allowed' if name.size != 1
-
-    case (param = name.keys.first.to_sym)
-      when :element   : @__children[name.values.first.to_sym]
-      when :child     : @__children[name.values.first.to_sym]
-      when :attr      : @__attributes[name.values.first.to_sym]
-      when :attribute : @__attributes[name.values.first.to_sym]
-      else raise %{ Invalid key :#{param.to_s}.
-        Use one of :element, :child, :attr, or :attribute }.squish!
-    end
-  end
-end

data/test/samples/lorem.xml

@@ -1,63 +0,0 @@
-<!-- Invalid method name test -->
-<lorem id="root" name="ipsum dolor sit amet" _tempor="incididunt">
-
-  <_minim>veniam</_minim> <!-- Invalid method name test -->
-
-  <!-- unambiguous element/attribute access test -->
-  <sed do="eiusmod attributus">
-    <do price="$8">eiusmod elementus</do>
-  </sed>
-
-  <!-- Blank test -->
-  <ipsum></ipsum>
-  <dolor foo="bar"></dolor>
-  <sit><amet></amet></sit>
-  <ut>quis</ut>
-
-  <!-- To test the array folding feature, as well as the pluralization.
-       The attributes help test float, integer, and boolean recognition,
-       as well as method name clashing behaviour (id) -->
-  <consectetur id="1" capacity="2.13" enabled="yes"   />
-  <consectetur id="2" capacity="-1.9" enabled="No"    />
-  <consectetur id="3" capacity="13.0" enabled="True"  />
-  <consectetur id="4" capacity="0.00" enabled="false" />
-
-  <!-- Test boolean recognition -->
-  <brutus>true</brutus>
-
-  <consecteturs> <!-- To test that we can still reach this, even though
-                      the array of singular ones above will trap the call
-                      to this when using dot notation -->
-    <culpa>officia</culpa>
-  </consecteturs>
-
-  <cupidatats> <!-- Test for the empty element == single array child
-                    scenario, as well as date recognition -->
-    <cupidatat activated_at="2903-02-12">Aliqua</cupidatat>
-    <cupidatat activated_at="2903-02-13">Occaecat</cupidatat>
-    <cupidatat activated_at="2904-10-18">Cupidatat</cupidatat>
-    <cupidatat activated_at="2905-03-21">Mollit</cupidatat>
-  </cupidatats>
-
-  <!-- Non-empty element, should not be array proxy -->
-  <voluptate>
-    velit
-    <esse>cillum</esse>
-    <esse>cillum dolore</esse>
-  </voluptate>
-
-  <!-- Test for both text value and CDATA value -->
-  <ullamco>Laboris<![CDATA[nisi]]></ullamco>
-
-  <!-- Test for multiple CDATA values -->
-  <deserunt><![CDATA[mollit]]><![CDATA[anim]]></deserunt>
-
-  <!-- Test for whitespace preservation / squishing -->
-  <irure metadata="  
-    	dolor  ">  
-			reprehenderit  </irure>
-
-<!-- CDATA whitespace preservation test -->
-<![CDATA[	 foo
-]]>
-</lorem>