solrizer 1.0.0 → 1.0.1

data/Gemfile

@@ -1,7 +1,7 @@
 source "http://rubygems.org"
 
-gem "solr-ruby"
 gem "nokogiri"
+gem "xml-simple"
 gem "om", ">= 1.0.0"  # only required by xml/terminology_based_solrizer ...
 gem "mediashelf-loggable"
 

data/Gemfile.lock

@@ -1,33 +1,30 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    columnize (0.3.1)
-    facets (2.9.0)
-    gemcutter (0.6.1)
+    columnize (0.3.2)
+    facets (2.9.1)
     git (1.2.5)
-    jeweler (1.4.0)
-      gemcutter (>= 0.1.0)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
       git (>= 1.2.5)
-      rubyforge (>= 2.0.0)
-    json_pure (1.4.6)
+      rake
     linecache (0.43)
     mediashelf-loggable (0.4.0)
-    mocha (0.9.9)
-      rake
-    nokogiri (1.4.3.1)
-    om (1.0.0)
+    mocha (0.9.12)
+    nokogiri (1.4.4)
+    om (1.0.2)
+      facets
       facets
+      nokogiri
       nokogiri (>= 1.4.2)
     rake (0.8.7)
     rspec (1.3.1)
-    ruby-debug (0.10.3)
+    ruby-debug (0.10.4)
       columnize (>= 0.1)
-      ruby-debug-base (~> 0.10.3.0)
-    ruby-debug-base (0.10.3)
+      ruby-debug-base (~> 0.10.4.0)
+    ruby-debug-base (0.10.4)
       linecache (>= 0.3)
-    rubyforge (2.0.4)
-      json_pure (>= 1.1.7)
-    solr-ruby (0.0.8)
+    xml-simple (1.0.14)
 
 PLATFORMS
   ruby
@@ -41,4 +38,4 @@ DEPENDENCIES
   rspec (< 2.0.0)
   ruby-debug
   ruby-debug-base
-  solr-ruby
+  xml-simple

data/History.txt

@@ -1,3 +1,18 @@
+h2. 1.0.0
+
+Deprecated
+
+* extract_tag
+* extract_tags
+* extract_hash
+
+
+All solrize and extract methods now accept and return a _Hash_ rather than a Solr::Document
+Removed dependency on outdated "solr" gem, replaced it with RSolr
+As part of this switch, *all field names are stored as Strings, not Symbols*. If you previously accessed something as solr_doc[:title_t], now you need to access it as solr_doc["title_t"] 
+
+Moved #format_node_value and #insert_solr_field_value from TerminologyBasedSolrizer to Solrizer::Extractor 
+
 h2. 0.3.1
 
 fix in require statements

data/Rakefile

@@ -10,7 +10,6 @@ begin
     gem.email = "matt.zumwalt@yourmediashelf.com"
     gem.homepage = "http://github.com/projecthydra/solrizer"
     gem.authors = ["Matt Zumwalt"]
-    gem.add_dependency "solr-ruby"
     gem.add_dependency "nokogiri"
     gem.add_dependency "om"
     gem.add_dependency "nokogiri"

data/VERSION

@@ -1 +1 @@
-0.3.2
+1.0.1

data/lib/solrizer/extractor.rb

@@ -1,5 +1,3 @@
-require 'solr'
-require 'rexml/document'
 require "nokogiri"
 require 'yaml'
 
@@ -12,37 +10,51 @@ module Solrizer
 # with methods specific to that implementation (ie. extract_tag, extract_rels_ext, xml_to_solr, html_to_solr)
 #
 class Extractor
-
-  # Populates a solr doc with values from a hash.  
-  # Accepts two forms of hashes:
-  # => {'technology'=>["t1", "t2"], 'company'=>"c1", "person"=>["p1", "p2"]}
-  # or
-  # => {:facets => {'technology'=>["t1", "t2"], 'company'=>"c1", "person"=>["p1", "p2"]} }
-  #
-  # Note that values for individual fields can be a single string or an array of strings.
-  def extract_hash( input_hash, solr_doc=Solr::Document.new )    
-    facets = input_hash.has_key?(:facets) ? input_hash[:facets] : input_hash
-    facets.each_pair do |facet_name, value|
-      case value.class.to_s
-      when "String"
-        solr_doc << Solr::Field.new( :"#{facet_name}_facet" => "#{value}" )
-      when "Array"
-        value.each { |v| solr_doc << Solr::Field.new( :"#{facet_name}_facet" => "#{v}" ) } 
-      end
-    end
-    
-    if input_hash.has_key?(:symbols) 
-      input_hash[:symbols].each do |symbol_name, value|
-        case value.class.to_s
-        when "String"
-          solr_doc << Solr::Field.new( :"#{symbol_name}_s" => "#{value}" )
-	      when "Array"
-          value.each { |v| solr_doc << Solr::Field.new( :"#{symbol_name}_s" => "#{v}" ) } 
-        end
-      end
+  
+  # Insert +field_value+ for +field_name+ into +solr_doc+
+  # Ensures that field values are always appended to arrays within the values hash. 
+  # Also ensures that values are run through format_node_value
+  # @param [Hash] solr_doc
+  # @param [String] field_name
+  # @param [String] field_value
+  def self.insert_solr_field_value(solr_doc, field_name, field_value)
+    formatted_value = self.format_node_value(field_value)
+    if solr_doc.has_key?(field_name)
+      solr_doc[field_name] << formatted_value
+    else
+      solr_doc.merge!( {field_name => [formatted_value]} ) 
     end
     return solr_doc
   end
   
+  # Strips the majority of whitespace from the values array and then joins them with a single blank delimitter
+  # @param [Array] values Array of strings representing the values returned 
+  def self.format_node_value values
+    values.map{|val| val.gsub(/\s+/,' ').strip}.join(" ")
+  end
+  
+  # Instance Methods
+  
+  # Alias for Solrizer::Extractor#insert_solr_field_value
+  def insert_solr_field_value(solr_doc, field_name, field_value)
+    Solrizer::Extractor.insert_solr_field_value(solr_doc, field_name, field_value)
+  end
+  
+  # Alias for Solrizer::Extractor#format_node_value
+  def format_node_value values
+    Solrizer::Extractor.format_node_value(values)
+  end
+  
+  # Deprecated.
+  # merges input_hash into solr_hash
+  # @param [Hash] input_hash the input hash of values
+  # @param [Hash] solr_hash the solr values hash to add the values into
+  # @return [Hash] the populated Solr values hash
+  # 
+  def extract_hash( input_hash, solr_hash=Hash.new )   
+    warn "[DEPRECATION] `extract_hash` is deprecated.  Just pass values directly into your solr values hash" 
+    return solr_hash.merge!(input_hash)
+  end
+  
 end
 end

data/lib/solrizer/html/extractor.rb

@@ -1,5 +1,3 @@
-require 'solr'
-require 'rexml/document'
 require "nokogiri"
 require 'yaml'
 
@@ -8,7 +6,9 @@ module Solrizer::HTML::Extractor
   #
   # This method strips html tags out and returns content to be indexed in solr
   #
-  def html_to_solr( ds, solr_doc=Solr::Document.new )
+  # @param [Datastream] ds object that responds to .content with HTML content
+  # @param [Hash] solr_doc hash of values to be inserted into solr as a solr document
+  def html_to_solr( ds, solr_doc=Hash.new )
     
     text = CGI.unescapeHTML(ds.content)
     doc = Nokogiri::HTML(text)
@@ -17,7 +17,7 @@ module Solrizer::HTML::Extractor
     stories = doc.xpath('//story')
         
     stories.each do |story|
-      solr_doc << Solr::Field.new(:story_display => story.children.to_xml)
+      solr_doc.merge!({:story_display => story.children.to_xml})
     end
     
     #strip out text and put in story_t
@@ -28,7 +28,7 @@ module Solrizer::HTML::Extractor
        text << text_node.content
      end
     
-     solr_doc << Solr::Field.new(:story_t => text)
+     solr_doc.merge!({:story_t => text})
      
      return solr_doc
   end

data/lib/solrizer/xml/extractor.rb

@@ -1,28 +1,29 @@
-require 'solr'
-require 'rexml/document'
-require "nokogiri"
-require 'yaml'
+require "xmlsimple"
 
 module Solrizer::XML::Extractor
-  
-  def extract_tags(text)
-    doc = REXML::Document.new( text )
-    extract_tag(doc, 'archivist_tags').merge(extract_tag(doc, 'donor_tags'))
-  end
-  
-  def extract_tag(doc, type)
-    tags = doc.elements["/fields/#{type}"]
-    return {} unless tags
-    {type => tags.text.split(/,/).map {|t| t.strip}}
-  end
 
   #
   # This method extracts solr fields from simple xml
+  # If you want to do anything more nuanced with the xml, use TerminologyBasedSolrizer instead.
   #
-  def xml_to_solr( text, solr_doc=Solr::Document.new )
-    doc = REXML::Document.new( text )
-    doc.root.elements.each do |element|
-      solr_doc << Solr::Field.new( :"#{element.name}_t" => "#{element.text}" )
+  # @param [xml] text xml content to index
+  # @param [Hash] solr_doc
+  def xml_to_solr( text, solr_doc=Hash.new )
+    doc = XmlSimple.xml_in( text )
+    
+    doc.each_pair do |name, value|
+      if value.kind_of?(Array) 
+        if value.first.kind_of?(Hash)
+          # This deals with the way xml-simple handles nodes with attributes
+          solr_doc.merge!({:"#{name}_t" => "#{value.first["content"]}"})
+        elsif value.length > 1
+          solr_doc.merge!({:"#{name}_t" => value})
+        else
+          solr_doc.merge!({:"#{name}_t" => "#{value}"})
+        end
+      else
+        solr_doc.merge!({:"#{name}_t" => "#{value}"})
+      end
     end
 
     return solr_doc

data/lib/solrizer/xml/terminology_based_solrizer.rb

@@ -8,9 +8,9 @@ module Solrizer::XML::TerminologyBasedSolrizer
   # Module Methods
   
   # Build a solr document from +doc+ based on its terminology
-  # @doc  OM::XML::Document
-  # @solr_doc (optional) Solr::Document to populate
-  def self.solrize(doc, solr_doc=Solr::Document.new, field_mapper = nil)
+  # @param [OM::XML::Document] doc  
+  # @param [Hash] (optional) solr_doc (values hash) to populate
+  def self.solrize(doc, solr_doc=Hash.new, field_mapper = nil)
     unless doc.class.terminology.nil?
       doc.class.terminology.terms.each_pair do |term_name,term|
         doc.solrize_term(term, solr_doc, field_mapper)
@@ -23,9 +23,10 @@ module Solrizer::XML::TerminologyBasedSolrizer
   
   # Populate a solr document with fields based on nodes in +xml+ corresponding to the 
   # term identified by +term_pointer+ within +terminology+
-  # @doc OM::XML::Document or Nokogiri::XML::Node
-  # @term_pointer Array pointing to the desired term in +terminology+  
-  def self.solrize_term(doc, term, solr_doc = Solr::Document.new, field_mapper = nil, opts={})
+  # @param [OM::XML::Document] doc xml document to extract values from
+  # @param [OM::XML::Term] term corresponding to desired xml values
+  # @param [Hash] (optional) solr_doc (values hash) to populate
+  def self.solrize_term(doc, term, solr_doc = Hash.new, field_mapper = nil, opts={})
     terminology = doc.class.terminology
     parents = opts.fetch(:parents, [])
 
@@ -52,10 +53,11 @@ module Solrizer::XML::TerminologyBasedSolrizer
   
   # Populate a solr document with solr fields corresponding to the given xml node
   # Field names are generated using settings from the term in the +doc+'s terminology corresponding to +term_pointer+
-  # @doc OM::XML::Document or Nokogiri::XML::Node
-  # @term_pointer Array pointing to the desired term in +terminology+
-  # @solr_doc (optional) Solr::Document to populate
-  def self.solrize_node(node, doc, term_pointer, term, solr_doc = Solr::Document.new, field_mapper = nil, opts = {})
+  # @param [Nokogiri::XML::Node] node to solrize
+  # @param [OM::XML::Document] doc document the node came from
+  # @param [Array] term_pointer Array pointing to the term that should be used for solrization settings
+  # @param [Hash] (optional) solr_doc (values hash) to populate
+  def self.solrize_node(node, doc, term_pointer, term, solr_doc = Hash.new, field_mapper = nil, opts = {})
     field_mapper ||= self.default_field_mapper
     terminology = doc.class.terminology
     # term = terminology.retrieve_term(*term_pointer)
@@ -70,7 +72,7 @@ module Solrizer::XML::TerminologyBasedSolrizer
     
     field_mapper.solr_names_and_values(generic_field_name_base, node_value, term.data_type, term.index_as).each do |field_name, field_value|
       unless field_value.join("").strip.blank?
-        solr_doc << Solr::Field.new(field_name => self.format_node_value(field_value)) 
+        ::Solrizer::Extractor.insert_solr_field_value(solr_doc, field_name, field_value)
       end
     end
     
@@ -78,32 +80,26 @@ module Solrizer::XML::TerminologyBasedSolrizer
       hierarchical_field_name_base = OM::XML::Terminology.term_hierarchical_name(*term_pointer)
       field_mapper.solr_names_and_values(hierarchical_field_name_base, node_value, term.data_type, term.index_as).each do |field_name, field_value|
         unless field_value.join("").strip.blank?
-          solr_doc << Solr::Field.new(field_name => self.format_node_value(field_value))
+          ::Solrizer::Extractor.insert_solr_field_value(solr_doc, field_name, field_value)
         end
       end
     end
     solr_doc
   end
-
-  # Strips the majority of whitespace from the values array and then joins them with a single blank delimitter
-  # @values Array of strings representing the values returned 
-  def self.format_node_value values
-    values.map{|val| val.gsub(/\s+/,' ').strip}.join(" ")
-  end
   
   # Instance Methods
   
   attr_accessor :field_mapper
   
-  def to_solr(solr_doc = Solr::Document.new, field_mapper = self.field_mapper) # :nodoc:
+  def to_solr(solr_doc = Hash.new, field_mapper = self.field_mapper) # :nodoc:
     Solrizer::XML::TerminologyBasedSolrizer.solrize(self, solr_doc, field_mapper)
   end
   
-  def solrize_term(term, solr_doc = Solr::Document.new, field_mapper = self.field_mapper, opts={})
+  def solrize_term(term, solr_doc = Hash.new, field_mapper = self.field_mapper, opts={})
     Solrizer::XML::TerminologyBasedSolrizer.solrize_term(self, term, solr_doc, field_mapper, opts)    
   end
   
-  def solrize_node(node, term_pointer, term, solr_doc = Solr::Document.new, field_mapper = self.field_mapper, opts={})
+  def solrize_node(node, term_pointer, term, solr_doc = Hash.new, field_mapper = self.field_mapper, opts={})
     Solrizer::XML::TerminologyBasedSolrizer.solrize_node(node, self, term_pointer, solr_doc, field_mapper, opts)
   end
   

data/solrizer.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{solrizer}
-  s.version = "1.0.0"
+  s.version = "1.0.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Matt Zumwalt"]

data/spec/units/extractor_spec.rb

@@ -7,52 +7,10 @@ describe Solrizer::Extractor do
     @extractor = Solrizer::Extractor.new
   end
   
-  describe "extract_hash" do
-    it "should convert a hash to a solr doc" do
-      example_hash = {"box"=>"Box 51A", "city"=>["Ann Arbor", "Hyderabad", "Palo Alto"], "person"=>["ELLIE ENGELMORE", "Reddy", "EDWARD FEIGENBAUM"], "title"=>"Letter from Ellie Engelmore to Professor K. C. Reddy", "series"=>"eaf7000", "folder"=>"Folder 15", "technology"=>["artificial intelligence"], "year"=>"1985", "organization"=>["Heuristic Programming Project", "Mathematics and Computer/Information Sciences University of Hyderabad Central University P. O. Hyder", "Professor K. C. Reddy School of Mathematics and Computer/Information Sciences"], "collection"=>"e-a-feigenbaum-collection", "state"=>["Michigan", "California"]}
-      
-      example_result = @extractor.extract_hash( example_hash )
-      example_result.should be_kind_of Solr::Document
-      example_hash.each_pair do |key,values|
-        if values.class == String
-          example_result["#{key}_facet"].should == values
-        else
-          values.each do |v|
-            example_result.inspect.include?("@name=\"#{key}_facet\"").should be_true
-            example_result.inspect.include?("@value=\"#{v}\"").should be_true
-          end
-        end        
-      end
-    end
-    
-    it "should handle hashes with facets listed in a sub-hash" do
-      simple_hash = Hash[:facets => {'technology'=>["t1", "t2"], 'company'=>"c1", "person"=>["p1", "p2"]}]
-      result = @extractor.extract_hash( simple_hash )
-      result.should be_kind_of Solr::Document
-      result["technology_facet"].should == "t1"
-      result.inspect.include?('@boost=nil').should be_true
-      result.inspect.include?('@name="technology_facet"').should be_true
-      result.inspect.include?('@value="t2"').should be_true
-      result["company_facet"].should == "c1"
-      result["person_facet"].should == "p1"
-      result.inspect.include?('@name="person_facet"').should be_true
-      result.inspect.include?('@value="p2"').should be_true
-      
-    end
-    
-    it "should create symbols from the :symbols subhash" do
-      simple_hash = Hash[:facets => {'technology'=>["t1", "t2"], 'company'=>"c1", "person"=>["p1", "p2"]}, :symbols=>{'technology'=>["t1", "t2"], 'company'=>"c1", "person"=>["p1", "p2"]}]
-      result = @extractor.extract_hash( simple_hash )
-      result.should be_kind_of Solr::Document
-      result["technology_s"].should == "t1"
-      result.inspect.include?('@name="technology_s"').should be_true
-      result.inspect.include?('@value="t2"').should be_true
-    
-      result["company_s"].should == "c1"
-      result["person_s"].should == "p1"
-      result.inspect.include?('@name="person_s"').should be_true
-      result.inspect.include?('@value="p2"').should be_true
-  
+  describe ".format_node_value" do
+    it "should strip white space out of the array and join it with a single blank" do
+      Solrizer::Extractor.format_node_value([" test    \n   node    \t value \t"]).should == "test node value"
+      Solrizer::Extractor.format_node_value([" test ", "     \n   node ", "   \t value \t"]).should == "test node value"
     end
   end
   

data/spec/units/xml_extractor_spec.rb

@@ -10,18 +10,19 @@ describe Solrizer::XML::Extractor do
   describe ".xml_to_solr" do
     it "should turn simple xml into a solr document" do
       desc_meta = fixture("druid-bv448hq0314-descMetadata.xml")
+
       result = @extractor.xml_to_solr(desc_meta)
       result[:type_t].should == "text"
       result[:medium_t].should == "Paper Document"
       result[:rights_t].should == "Presumed under copyright. Do not publish."
       result[:date_t].should == "1985-12-30"
-      result[:format_t].should == "application/tiff"
+      result[:format_t].should be_kind_of(Array)
+      result[:format_t].should include("application/tiff")
+      result[:format_t].should include("application/pdf")
+      result[:format_t].should include("application/jp2000")
       result[:title_t].should == "This is a Sample Title"
       result[:publisher_t].should == "Sample Unversity"
 
-      # ... and a hacky way of making sure that it added a field for each of the dc:medium values
-      result.inspect.include?('@value="application/tiff"').should be_true
-      result.inspect.include?('@value="application/pdf"').should be_true
     end
   end
   

data/spec/units/xml_terminology_based_solrizer_spec.rb

@@ -22,18 +22,18 @@ describe Solrizer::XML::TerminologyBasedSolrizer do
   
     it "should provide .to_solr and return a SolrDocument" do
       @mods_article.should respond_to(:to_solr)
-      @mods_article.to_solr.should be_kind_of(Solr::Document)
+      @mods_article.to_solr.should be_kind_of(Hash)
     end
   
-    it "should optionally allow you to provide the Solr::Document to add fields to and return that document when done" do
-      doc = Solr::Document.new
+    it "should optionally allow you to provide the Hash to add fields to and return that document when done" do
+      doc = Hash.new
       @mods_article.to_solr(doc).should equal(doc)
     end
   
     it "should iterate through the terminology terms, calling .solrize_term on each and passing in the solr doc" do
       # mock_terms = {:name1=>:term1, :name2=>:term2}
       # ActiveFedora::NokogiriDatastream.stubs(:accessors).returns(mock_accessors)
-      solr_doc = Solr::Document.new
+      solr_doc = Hash.new
       @mods_article.field_mapper = Solrizer::FieldMapper::Default.new
       OM::Samples::ModsArticle.terminology.terms.each_pair do |k,v|
         @mods_article.expects(:solrize_term).with(v, solr_doc, @mods_article.field_mapper)
@@ -46,10 +46,13 @@ describe Solrizer::XML::TerminologyBasedSolrizer do
       solr_doc =  @mods_article.to_solr
       #should have these
       
-      solr_doc[:abstract].should be_nil
-      solr_doc[:abstract_t].should == "ABSTRACT"
-      solr_doc[:title_info_1_language_t].should == "finnish"
-      solr_doc[:person_1_role_0_text_t].should == "teacher"
+      solr_doc["abstract"].should be_nil
+      solr_doc["abstract_t"].should == ["ABSTRACT"]
+      solr_doc["title_info_1_language_t"].should == ["finnish"]
+      solr_doc["person_1_role_0_text_t"].should == ["teacher"]
+      solr_doc["person_last_name_t"].sort.should == ["FAMILY NAME", "Gautama"]
+      # This next line will fail until om > 1.0.2 is released
+      # solr_doc["topic_tag_t"].sort.should == ["CONTROLLED TERM", "TOPIC1", "TOPIC2"]
       
       # These are a holdover from an old verison of OM
       # solr_doc[:finnish_title_info_language_t].should == "finnish"
@@ -69,19 +72,19 @@ describe Solrizer::XML::TerminologyBasedSolrizer do
   describe ".solrize_term" do
   
     it "should add fields to a solr document for all nodes corresponding to the given term and its children" do
-      solr_doc = Solr::Document.new
+      solr_doc = Hash.new
       result = @mods_article.solrize_term(OM::Samples::ModsArticle.terminology.retrieve_term(:title_info), solr_doc)
       result.should == solr_doc
       # @mods_article.solrize_term(:title_info, OM::Samples::ModsArticle.terminology.retrieve_term(:title_info), :solr_doc=>solr_doc).should == ""
     end
 
     it "should add multiple fields based on index_as" do
-      fake_solr_doc = []  # duck typing cheat: test will break if solrize_term decides to use methods other than <<
+      fake_solr_doc = {}
       @mods_article.solrize_term(OM::Samples::ModsArticle.terminology.retrieve_term(:name), fake_solr_doc)
       
       expected_names = ["DR.", "FAMILY NAME", "GIVEN NAMES"]
       %w(_t _display _facet).each do |suffix|
-        actual_names = fake_solr_doc.select { |field| field.name == 'name_0_namePart' + suffix }.map { |field| field.value }.sort
+        actual_names = fake_solr_doc["name_0_namePart#{suffix}"].sort
         {suffix => actual_names}.should == {suffix => expected_names}
       end
     end
@@ -89,8 +92,8 @@ describe Solrizer::XML::TerminologyBasedSolrizer do
   end
 
   describe ".solrize_node" do
-    it "should optionally allow you to provide the Solr::Document to add fields to and return that document when done" do
-      doc = Solr::Document.new
+    it "should optionally allow you to provide the Hash to add fields to and return that document when done" do
+      doc = Hash.new
       # @mods_article.solrize_node(node, term_pointer, term, solr_doc).should equal(doc)
     end
     
@@ -99,10 +102,4 @@ describe Solrizer::XML::TerminologyBasedSolrizer do
     it "should only create one node if parents is empty"
   end
 
-  describe ".format_node_value" do
-    it "should strip white space out of the array and join it with a single blank" do
-      Solrizer::XML::TerminologyBasedSolrizer.format_node_value([" test    \n   node    \t value \t"]).should == "test node value"
-      Solrizer::XML::TerminologyBasedSolrizer.format_node_value([" test ", "     \n   node ", "   \t value \t"]).should == "test node value"
-    end
-  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: solrizer
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: false
   segments: 
   - 1
   - 0
-  - 0
-  version: 1.0.0
+  - 1
+  version: 1.0.1
 platform: ruby
 authors: 
 - Matt Zumwalt