muffins 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in muffins.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/features/basic_parsing.feature

@@ -0,0 +1,33 @@
+Feature: Basic Parsing
+  As an XML mapping library
+  I'd like to be awesome at mapping
+  So I can get hella downloads
+
+  Background:
+    Given the following xml:
+      """
+      <?xml version=\"1.0\" encoding=\"UTF-8\"?>
+      <books>
+        <book>
+          <asin>1400079985</asin>
+          <title>War and Peace (Vintage Classics)</title>
+        </book>
+        <book>
+          <asin>1143035008</asin>
+          <title>Anna Karenina (Oprah's Book Club)</title>
+        </book>
+      </books>
+      """
+
+  Scenario: I parse the xml
+    Given that base_path has been set to 'book'
+      And the following mappings have been defined:
+        | name  |
+        | asin  |
+        | title |
+     When I parse the xml
+     Then I should have 2 books
+      And the following values should be returned:
+        |       asin | title                             |
+        | 1400079985 | War and Peace (Vintage Classics)  |
+        | 1143035008 | Anna Karenina (Oprah's Book Club) |

data/features/nested_parsing.feature

@@ -0,0 +1,37 @@
+Feature: Nested Parsing
+  As an XML mapping library
+  I'd like to be awesome at mapping
+  So I can get hella downloads
+
+  Background:
+    Given the following xml:
+      """
+      <?xml version=\"1.0\" encoding=\"UTF-8\"?>
+      <books>
+        <book>
+          <asin>1400079985</asin>
+          <itemattributes>
+            <title>War and Peace (Vintage Classics)</title>
+          </itemattributes>
+        </book>
+        <book>
+          <asin>1143035008</asin>
+          <itemattributes>
+            <title>Anna Karenina (Oprah's Book Club)</title>
+          </itemattributes>
+        </book>
+      </books>
+      """
+  Scenario: I parse the xml
+    Given that base_path has been set to 'book'
+      And the following mappings have been defined:
+        | name  | within         |
+        | asin  |                |
+        | title | itemattributes |
+     When I parse the xml
+     Then I should have 2 books
+      And the following values should be returned:
+        |       asin | title                             |
+        | 1400079985 | War and Peace (Vintage Classics)  |
+        | 1143035008 | Anna Karenina (Oprah's Book Club) |
+

data/features/non_primitive_typing.feature

@@ -0,0 +1,36 @@
+Feature: Non-Primitive Typing
+  As an XML mapping library
+  I'd like to be awesome at mapping
+  So I can get hella downloads
+
+  Background:
+    Given the following xml:
+      """
+      <?xml version=\"1.0\" encoding=\"UTF-8\"?>
+      <books>
+        <book>
+          <asin>1400079985</asin>
+          <title>War and Peace (Vintage Classics)</title>
+          <similarproducts>
+            <product>
+              <asin>1143035008</asin>
+              <title>Anna Karenina (Oprah's Book Club)</title>
+            </product>
+          </similarproducts>
+        </book>
+      </books>
+      """
+
+  Scenario: I parse the xml
+    Given that base_path has been set to 'book'
+      And the following mappings have been defined:
+        | name            | type     |
+        | asin            |          |
+        | title           |          |
+        | similarproducts | Product  |
+     When I parse the xml
+     Then I should have 1 books
+      And the following values should be returned:
+        |       asin | title                             |
+        | 1400079985 | War and Peace (Vintage Classics)  |
+      And 'similarproducts' should return 1 instances of Product

data/features/specified_pathnames.feature

@@ -0,0 +1,33 @@
+Feature: Specified Pathnames
+  As an XML mapping library
+  I'd like to be awesome at mapping
+  So I can get hella downloads
+
+  Background:
+    Given the following xml:
+      """
+      <?xml version=\"1.0\" encoding=\"UTF-8\"?>
+      <BOOKS>
+        <BOOK>
+          <ASIN>1400079985</ASIN>
+          <TITLE>War and Peace (Vintage Classics)</TITLE>
+        </BOOK>
+        <BOOK>
+          <ASIN>1143035008</ASIN>
+          <TITLE>Anna Karenina (Oprah's Book Club)</TITLE>
+        </BOOK>
+      </BOOKS>
+      """
+  Scenario: I parse the xml
+    Given that base_path has been set to 'BOOK'
+      And the following mappings have been defined:
+        | name  | to    |
+        | asin  | ASIN  |
+        | title | TITLE |
+     When I parse the xml
+     Then I should have 2 books
+      And the following values should be returned:
+        |       asin | title                             |
+        | 1400079985 | War and Peace (Vintage Classics)  |
+        | 1143035008 | Anna Karenina (Oprah's Book Club) |
+

data/features/specified_typing.feature

@@ -0,0 +1,33 @@
+Feature: Specified Typing
+  As an XML mapping library
+  I'd like to be awesome at mapping
+  So I can get hella downloads
+
+  Background:
+    Given the following xml:
+      """
+      <?xml version=\"1.0\" encoding=\"UTF-8\"?>
+      <books>
+        <book>
+          <asin>1400079985</asin>
+          <title>War and Peace (Vintage Classics)</title>
+        </book>
+        <book>
+          <asin>1143035008</asin>
+          <title>Anna Karenina (Oprah's Book Club)</title>
+        </book>
+      </books>
+      """
+  Scenario: I parse the xml
+    Given that base_path has been set to 'book'
+      And the following mappings have been defined:
+        | name  | type    |
+        | asin  | Integer |
+        | title | String  |
+     When I parse the xml
+     Then I should have 2 books
+      And the following data types should be returned:
+        | asin    | title  |
+        | Integer | String |
+        | Integer | String |
+

data/features/step_definitions/application_steps.rb

@@ -0,0 +1,52 @@
+Given /^the following xml:$/ do |doc|
+  @xml = Nokogiri::XML(doc)
+end
+
+Given /^that base_path has been set to '(.*?)'$/ do |base_path|
+  Book.base_path base_path
+end
+
+Given /^the following mappings have been defined:$/ do |table|
+  table.hashes.each do |options|
+    name = options.delete('name')
+    Book.map name, options
+  end
+end
+
+
+When /^I parse the xml$/ do
+  @books = Book.parse(@xml)
+end
+
+Then /^I should have (\d+) books$/ do |count|
+  @books.count.should == count.to_i
+end
+
+Then /^the following values should be returned:$/ do |table|
+  @books.count.times do |count|
+    book = @books[count]
+
+    table.hashes[count].each_pair do |key, value|
+      book.send(key).should == value
+    end
+  end
+end
+
+Then /^the following data types should be returned:$/ do |table|
+  @books.count.times do |count|
+    book = @books[count]
+
+    table.hashes[count].each_pair do |key, value|
+      type = value.constantize
+      book.send(key).should be_a(type)
+    end
+  end
+end
+
+Then /^'(.*?)' should return (\d+) instances of (.*?)$/ do |method, count, type|
+  @books.each do |book|
+    products = book.send(method)
+    products.count.should == count.to_i
+    products.each {|p| p.should be_a(type.constantize) }
+  end
+end

data/features/support/env.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'nokogiri'
+require 'activesupport'
+require 'muffins'
+
+
+class Book
+  include Muffins
+end
+
+class Product
+  include Muffins
+
+  base_path 'product'
+end

data/lib/muffins.rb

@@ -0,0 +1,43 @@
+require "muffins/mapping"
+require "muffins/mapping_decorator"
+require "muffins/version"
+
+module Muffins
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+
+    def base_path(bp = nil)
+      @base_path = bp if bp
+      @base_path
+    end
+
+    def parse(document, options = {})
+      document.css(base_path).collect do |node|
+        (new).tap do |object|
+
+          mappings.each do |mapping|
+            object.send("#{mapping.name}=", mapping.map(node))
+          end
+
+        end
+      end
+    end
+
+    def within(path, &block)
+      yield MappingDecorator.new(path, self)
+    end
+
+    def map(symbol, options = {})
+      attr_accessor symbol unless new.respond_to?(symbol)
+
+      mappings << Mapping.new(symbol, options)
+    end
+
+    def mappings
+      @mappings ||= []
+    end
+  end
+end

data/lib/muffins/mapping.rb

@@ -0,0 +1,73 @@
+module Muffins
+  class Mapping
+    
+    PRIMITIVE_TYPES = [String, Float, Time, Date, DateTime, Integer]
+
+    attr_reader :name, :options
+
+    def initialize(name, options = {})
+      @name    = name
+      @options = options
+    end
+
+    def map(document)
+      if collection?
+        ([]).tap do |items|
+          document.css(path).each do |node|
+            items << typecast(node)
+          end
+        end
+      else
+        typecast document.at_css(path)
+      end
+    end
+
+    def path
+      path = options[:to].present? ? options[:to] : name
+
+      unless options[:within].blank?
+        path = "#{options[:within]} > #{path}"
+      end
+
+      @path ||= path
+    end
+
+    def collection?
+      !!options[:collection]
+    end
+
+    def primitive?
+      PRIMITIVE_TYPES.include? options[:type].constantize
+    end
+
+    def typecast(node)
+      value, constant = node.try(:text), "#{options[:type]}"
+
+      return value if value.blank? || constant.blank?
+
+      constant = constant.constantize
+
+      if primitive?
+        if constant == String
+          value.to_s
+        elsif constant == Float
+          value.to_f
+        elsif constant == Time
+          Time.parse(value) rescue Time.at(value.to_i)
+        elsif constant == Date
+          Date.parse(value)
+        elsif constant == DateTime
+          DateTime.parse(value)
+        elsif constant == Integer
+          value.to_i
+        else
+          value
+        end
+
+      else
+        constant.parse(node)
+      end
+
+    end
+  end
+end

data/lib/muffins/mapping_decorator.rb

@@ -0,0 +1,22 @@
+module Muffins
+  class MappingDecorator
+
+    attr_reader :base_path, :object
+
+    def initialize(base_path, object)
+      @base_path = base_path
+      @object    = object
+    end
+
+    def map(name, options = {})
+      options[:within] =
+        if options[:within]
+          "#{base_path} > #{options[:within]}"
+        else
+          base_path
+        end
+
+      object.map(name, options)
+    end
+  end
+end

data/lib/muffins/version.rb

@@ -0,0 +1,3 @@
+module Muffins
+  VERSION = "0.0.1"
+end

data/muffins.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "muffins/version"
+
+Gem::Specification.new do |s|
+  s.name        = "muffins"
+  s.version     = Muffins::VERSION
+  s.authors     = ["Ryan Closner"]
+  s.email       = ["ryan.closner@gmail.com"]
+  s.homepage    = "https://rubygems.org/gems/muffins"
+  s.summary     = %q{An Object to XML/HTML mapping library using Nokogiri}
+  s.description = %q{An Object to XML/HTML mapping library using Nokogiri}
+
+  s.rubyforge_project = "muffins"
+
+  {
+    'activesupport'       => '~> 2.3.10',    
+    'nokogiri'            => '~> 1.4'
+  }.each do |lib, version|
+    s.add_runtime_dependency lib, version
+  end
+
+
+  {
+    'bundler'             => '~> 1.0',
+    'cucumber'            => '~> 0.10',
+    'rspec'               => '~> 2.6',
+  }.each do |lib, version|
+    s.add_development_dependency lib, version
+  end
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/mapping_spec.rb

@@ -0,0 +1,219 @@
+require 'spec_helper'
+
+module Muffins
+  describe Mapping do
+
+    let(:name)    { :foo }
+    let(:options) { {} }
+
+    let(:document) { mock(Nokogiri::XML::Document) }
+
+    let(:node)     { mock(Nokogiri::XML::Node) }
+    let(:nodes)    { [node] }
+
+    let(:value)    { 'bar' }
+    let(:values)   { [value] }
+
+    subject { Mapping.new(name, options) }
+
+    describe "#map" do
+      before(:each) do
+        subject.stub(:typecast).with(node).and_return(value)
+      end
+
+      context "#collection? returns true" do
+        before(:each) do
+          subject.stub(:collection?).and_return(true)
+
+          document.stub(:css).and_return(nodes)
+        end
+
+        it "typecasts the parsed values" do
+          subject.should_receive(:typecast).with(node).and_return(value)
+          subject.map(document)
+        end
+
+        it "returns an array of typecasted values" do
+          subject.map(document).should == values
+        end
+      end
+
+      context "#collection? returns false" do
+        before(:each) do
+          subject.stub(:collection?).and_return(false)
+
+          document.stub(:at_css).and_return(node)
+        end
+
+        it "typecasts the parsed value" do
+          subject.should_receive(:typecast).with(node).and_return(value)
+          subject.map(document)
+        end
+
+        it "returns the typecasted value" do
+          subject.map(document).should == value
+        end
+      end
+    end
+
+    describe "#path" do
+      context "no options are passed" do
+        it "returns the mapping name" do
+          subject.path.should == name
+        end
+      end
+
+      context "options[:to] is passed" do
+        let(:to)    { 'bar' }
+        let(:options) { {:to => to} }
+
+        before(:each) do
+          subject.stub(:options).and_return(options)
+        end
+
+        it "returns the passed path name" do
+          subject.path.should == to
+        end
+      end
+
+      context "options[:within] is passed" do
+        let(:within) { 'parent' }
+        let(:to)     { 'child' }
+
+        let(:options) { {:within => within, :to => to} }
+
+        before(:each) do
+          subject.stub(:options).and_return(options)
+        end
+
+        it "returns the css selector with parent and child" do
+          subject.path.should == "#{within} > #{to}"
+        end
+      end
+    end
+
+    describe "#collection?" do
+      context "options[:collection] is nil" do
+        it "returns false" do
+          subject.collection?.should be_false
+        end
+      end
+
+      context "options[:collection] is false" do
+
+        let(:options) { {:collection => false} }
+
+        before(:each) do
+          subject.stub(:options).and_return(options)
+        end
+
+        it "returns false" do
+          subject.collection?.should be_false
+        end
+      end
+
+      context "options[:collection] is true" do
+
+        let(:options) { {:collection => true} }
+
+        before(:each) do
+          subject.stub(:options).and_return(options)
+        end
+
+        it "returns true" do
+          subject.collection?.should be_true
+        end
+      end
+    end
+
+    describe "#primitive?" do
+    end
+
+    describe "#typecast" do
+
+      before(:each) do
+        node.stub(:try).with(:text).and_return(value)
+
+        subject.stub(:options).and_return(options)
+      end
+
+      context "#primitive? returns true" do
+
+        before(:each) do
+          subject.stub(:primitive?).and_return(true)
+        end
+
+        context "options[:type] = String" do
+          let(:options) { {:type => String} }
+
+          it "returns an instance of String" do
+            subject.typecast(node).should be_a(String)
+          end
+        end
+
+        context "options[:type] = Float" do
+          let(:options) { {:type => Float} }
+          let(:value)   { '10.01' }
+
+          it "returns an instance of Float" do
+            subject.typecast(node).should be_a(Float)
+          end
+        end
+
+        context "options[:type] = Time" do
+          let(:options) { {:type => Time} }
+
+          let(:value)   { '00:00:00 -0700' }
+
+          it "returns an instance of Time" do
+            subject.typecast(node).should be_a(Time)
+          end
+        end
+
+        context "options[:type] = Date" do
+          let(:options) { {:type => Date} }
+
+          let(:value)   { '2011-01-01' }
+
+          it "returns an instance of Date" do
+            subject.typecast(node).should be_a(Date)
+          end
+        end
+
+        context "options[:type] = DateTime" do
+          let(:options) { {:type => DateTime} }
+
+          let(:value)   { '2011-01-01 00:00:00 -0700' }
+
+          it "returns an instance of DateTime" do
+            subject.typecast(node).should be_a(DateTime)
+          end
+        end
+
+        context "options[:type] = Integer" do
+          let(:options) { {:type => Integer} }
+
+          let(:value)   { '12908234' }
+
+          it "returns an instance of Integer" do
+            subject.typecast(node).should be_a(Integer)
+          end
+        end
+      end
+
+      context "#primitive? returns false" do
+        let(:options) { {:type => Book} }
+
+        before(:each) do
+          subject.stub(:primitive?).and_return(false)
+        end
+
+        it "attempts to parse the nested set" do
+          Book.should_receive(:parse).with(node)
+          subject.typecast(node)
+        end
+      end
+    end
+  end
+end
+

data/spec/muffins/mapping_decorator_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+module Muffins
+  describe MappingDecorator do
+
+    let(:object) do
+      class Book
+        include Muffins
+      end
+    end
+
+    let(:base_path) { 'foo' }
+    let(:name)      { 'bar' }
+
+    let(:decorator_options)   { {} }
+
+    let(:nested_path) { 'foobar' }
+
+    subject { MappingDecorator.new(base_path, object) }
+
+    describe "#map" do
+      context "options[:within] is nil" do
+
+        let(:mapping_options) { {:within => base_path } }
+
+        it "sets options[:within] to the base_path" do
+          object.should_receive(:map).with(name, mapping_options)
+          subject.map(name, decorator_options)
+        end
+      end
+
+      context "options[:within] is not nil" do
+
+        let(:mapping_options) { {:within => "#{base_path} > #{nested_path}"} }
+
+        let(:decorator_options) { {:within => nested_path} }
+
+
+        it "sets options[:within] to the 'base_path > nested_path'" do
+          object.should_receive(:map).with(name, mapping_options)
+          subject.map(name, decorator_options)
+        end
+      end
+    end
+  end
+end

data/spec/muffins_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe Muffins do
+
+  context "when included in a class" do
+
+    subject do
+      class Book
+        include Muffins
+      end
+    end
+
+    let(:book) { mock(Book) }
+
+    let(:mapping)         { mock(Muffins::Mapping) }
+    let(:mapping_name)    { :foo }
+    let(:mapping_options) { {} }
+
+
+    describe ".mappings" do
+      it "returns an array" do
+        subject.mappings.should be_an(Array)
+      end
+    end
+
+    describe ".base_path" do
+      context "value is passed" do
+        it "sets @base_path to the passed value" do
+          subject.base_path('book')
+          subject.instance_variable_get(:@base_path).should == 'book'
+        end
+      end
+
+      context "no value is passed" do
+        it "returns the value of @base_path" do
+          subject.instance_variable_set(:@base_path, 'book')
+          subject.base_path.should == 'book'
+        end
+      end
+    end
+
+    describe ".parse" do
+      let(:document)  { mock(Nokogiri::XML::Document) }
+      let(:node)      { mock(Nokogiri::XML::Node) }
+
+      let(:nodes)     { [node] }
+
+      let(:base_path) { 'book' }
+      let(:mappings)  { [mapping] }
+
+      let(:mapping_value) { 'bar' }
+
+      before(:each) do
+        subject.stub(:base_path).and_return(base_path)
+        subject.stub(:new).and_return(book)
+        subject.stub(:mappings).and_return(mappings)
+
+        book.stub("#{mapping_name}=")
+
+        document.stub(:css).with(base_path).and_return(nodes)
+
+        mapping.stub(:name).and_return(mapping_name)
+        mapping.stub(:map).with(node).and_return(mapping_value)
+      end
+
+      it "sets klass#method_name to the mapped node value" do
+        book.should_receive("#{mapping_name}=").with(mapping_value)
+        subject.parse(document)
+      end
+
+      it "returns an array of klasses" do
+        subject.parse(document).should == [book]
+      end
+    end
+
+    describe ".within" do
+      it "yields an instance of Muffins::MappingDecorator" do
+        subject.within :foo do |foo|
+          foo.should be_a(Muffins::MappingDecorator)
+        end
+      end
+    end
+
+    describe ".map" do
+
+      let(:mappings)        { [] }
+
+      before(:each) do
+        Muffins::Mapping.stub(:new)
+          .with(mapping_name, mapping_options)
+          .and_return(mapping)
+
+
+        book.stub(:respond_to?).with(mapping_name)
+        subject.stub(:new).and_return(book)
+
+        subject.stub(:mappings).and_return(mappings)
+      end
+
+      it "adds a new instance of Muffins::Mapping to .mappings" do
+        mappings.should_receive(:<<).with(mapping)
+        subject.map mapping_name, mapping_options
+      end
+
+      context "the mapping name is not a defined method" do
+        before(:each) do
+          book.stub(:respond_to?).with(mapping_name).and_return(false)
+        end
+
+        it "defines an attr_accessor for the mapping name" do
+          subject.should_receive(:attr_accessor).with(mapping_name)
+          subject.map mapping_name
+        end
+      end
+
+      context "the mapping name is already a defined method" do
+        before(:each) do
+          book.stub(:respond_to?).with(mapping_name).and_return(true)
+        end
+
+        it "does not overwrite the existing method" do
+          subject.should_not_receive(:attr_accessor).with(mapping_name)
+          subject.map mapping_name
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec'
+require 'nokogiri'
+require 'activesupport'
+
+require File.expand_path('../../lib/muffins', __FILE__)
+
+def fixture_file(filename)
+  File.read(File.dirname(__FILE__) + "/fixtures/#{filename}")
+end
+

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: muffins
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ryan Closner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-07-09 00:00:00.000000000 -07:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &15895880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.10
+  type: :runtime
+  prerelease: false
+  version_requirements: *15895880
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: &15895400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: *15895400
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &15894760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: *15894760
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: &15894320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: *15894320
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &15893880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: *15893880
+description: An Object to XML/HTML mapping library using Nokogiri
+email:
+- ryan.closner@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- features/basic_parsing.feature
+- features/nested_parsing.feature
+- features/non_primitive_typing.feature
+- features/specified_pathnames.feature
+- features/specified_typing.feature
+- features/step_definitions/application_steps.rb
+- features/support/env.rb
+- lib/muffins.rb
+- lib/muffins/mapping.rb
+- lib/muffins/mapping_decorator.rb
+- lib/muffins/version.rb
+- muffins.gemspec
+- spec/mapping_spec.rb
+- spec/muffins/mapping_decorator_spec.rb
+- spec/muffins_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://rubygems.org/gems/muffins
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: muffins
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: An Object to XML/HTML mapping library using Nokogiri
+test_files:
+- features/basic_parsing.feature
+- features/nested_parsing.feature
+- features/non_primitive_typing.feature
+- features/specified_pathnames.feature
+- features/specified_typing.feature
+- features/step_definitions/application_steps.rb
+- features/support/env.rb
+- spec/mapping_spec.rb
+- spec/muffins/mapping_decorator_spec.rb
+- spec/muffins_spec.rb
+- spec/spec_helper.rb