music_story 1.0.2

data/README.txt

@@ -0,0 +1,13 @@
+Wrapper code for MusicStory data products.
+
+Usage:
+
+    MusicStory::XMLParser.each_in_file('music-story-data.xml') do |artist|
+      puts artist.name
+      puts artist.plain_text_bio
+      puts artist.main_genres[0].id
+      # see MusicStory::{Artist,Genre} for more available properties
+    end
+
+Should be able to cope with big XML files, as it uses an XML::Reader to scan through
+the file one artist at a time; only the current artist object is kept in memory. (Although only tried it on a 330KB file so far so YMMV...)

data/lib/music_story.rb

@@ -0,0 +1,25 @@
+module MusicStory
+  module Model; end
+  module Repository; end
+  module Utils; end
+end
+
+# alias it
+Musicstory = MusicStory
+
+require 'nokogiri'
+require 'music_story/utils/html_to_text'
+require 'music_story/utils/xml_to_db_importer'
+
+require 'thin_models/struct/identity'
+require 'music_story/model/artist'
+require 'music_story/model/genre'
+
+require 'music_story/repository/artist_xml_file'
+
+require 'sequel'
+require 'persistence'
+require 'persistence/sequel'
+require 'music_story/repository/artist_sequel'
+require 'music_story/repository/genre_sequel'
+require 'music_story/repository/sequel'

data/lib/music_story/model/artist.rb

@@ -0,0 +1,56 @@
+module MusicStory
+  class Model::Artist < ThinModels::Struct
+    identity_attribute :id # MusicStory identifier
+    attribute :name        # 'nom' at source
+    attribute :forename    # 'prenom' at source
+    attribute :real_name   # 'nom_reel' at source
+    attribute :role
+    attribute :type
+    attribute :country     # 'pays' at source
+    attribute :image_filename
+
+    # Called 'resume' and 'texte_bio' in the MusicStory XML.
+    # Not sure what the appropriate translation for resume vs texte_bio is here,
+    # but in data seen so far they are both the same except that texte_bio has a
+    # credit/copyright line added at the end. Both are given as html, not plain
+    # text. (But see plain_text_{bio,summary})
+    attribute :summary_html
+    attribute :bio_html
+
+    attribute :main_genres
+    attribute :secondary_genres
+    attribute :influenced_by_genres
+
+    def all_genres
+      (main_genres + secondary_genres + influenced_by_genres).uniq
+    end
+
+    attribute :similar_artists
+    attribute :influenced_by_artists
+
+    # 'successor' was MusicStory's English translation, appears to mean 'is succeeded by'
+    # or perhaps more accurately 'influenced' / 'was followed by'. From their example sounds
+    # like it's similar semantics to 'influenced by' but in the opposite direction:
+    #
+    # <associe id_artiste="3795" id_associe="454" nom_associe="Michael Jackson">S</associe>
+    # "id_artist 3795 is Diana Ross et id_associe 454 is Michael Jackson.
+    # The relation means that Micheal Jackson is a successor of Diana Ross.
+    # The reverse isn't not always true, Michael Jackson will not necessarily be mentioned
+    # as influenced by Diana Ross"
+    attribute :successor_artists
+
+    def all_associated_artists
+      (similar_artists + influenced_by_artists + successor_artists).uniq
+    end
+
+    # The bio html converted to plain text, see HTMLToText
+    def plain_text_bio
+      bio_html && Utils::HTMLToText.convert(bio_html)
+    end
+
+    # The summary html converted to plain text, see HTMLToText
+    def plain_text_summary
+      summary_html && Utils::HTMLToText.convert(summary_html)
+    end
+  end
+end

data/lib/music_story/model/batch.rb

@@ -0,0 +1,21 @@
+module MusicStory::Model
+  class Batch < ThinModels::Struct
+    attribute :path
+    attribute :state
+
+    DATE_PATTERN = /([0-9]{4})\-([0-9]{2})\-([0-9]{2})/
+
+    def date
+      m = DATE_PATTERN.match(File.basename(path))
+      m && Date.new(m[1].to_i, m[2].to_i, m[3].to_i)
+    end
+
+    def to_s
+      "#<Batch path=#{path}>"
+    end
+
+    def ==(rhs)
+      rhs && rhs.is_a?(Batch) && rhs.path == self.path
+    end
+  end
+end

data/lib/music_story/model/genre.rb

@@ -0,0 +1,7 @@
+module MusicStory
+  class Model::Genre < ThinModels::Struct
+    identity_attribute :id # MusicStory identifier
+    attribute :name
+    alias :to_s :name
+  end
+end

data/lib/music_story/repository/artist_sequel.rb

@@ -0,0 +1,35 @@
+module MusicStory
+  class Repository::ArtistSequel < Persistence::Sequel::IdentitySetRepository
+    set_model_class Model::Artist
+    use_table :artists, :id_sequence => true
+    map_column :name
+    map_column :forename
+    map_column :real_name
+    map_column :role
+    map_column :type
+    map_column :country
+    map_column :summary_html
+    map_column :image_filename
+    map_column :bio_html
+
+    [:similar, :influenced_by, :successor].each do |rel|
+      map_many_to_many :"#{rel}_artists",
+        :model_class => Model::Artist,
+        :join_table  => :artist_associations,
+        :filter      => {:relation => rel.to_s},
+        :left_key    => :from_artist_id,
+        :right_key   => :to_artist_id,
+        :writeable   => true
+    end
+
+    [:main, :secondary, :influenced_by].each do |rel|
+      map_many_to_many :"#{rel}_genres",
+        :model_class => Model::Genre,
+        :join_table  => :artist_genres,
+        :filter      => {:relation => rel.to_s},
+        :left_key    => :artist_id,
+        :right_key   => :genre_id,
+        :writeable   => true
+    end
+  end
+end

data/lib/music_story/repository/artist_xml_file.rb

@@ -0,0 +1,113 @@
+module MusicStory
+  # Parses an XML file of MusicStory artiste objects.
+  # The top-level structure should be
+  # <items>...<artistes><artist>...</artist>...<artist>...</artist></artistes></items>.
+  #
+  # A formal XSD doesn't appear to exist, so this is based entirely on data seen so far,
+  # together with some small pieces of info (such as the ARTIST_GENRE_RELATIONS and
+  # ASSOCIATION_TYPES) gleaned from a brief PDF doc in franglais (descriptionxml_en.pdf).
+  #
+  # Some elements mentioned in the PDF (such as collaboration, album, evenement etc)
+  # haven't been seen so far in artist XML files so aren't handled.
+  class Repository::ArtistXMLFile
+    def initialize(io)
+      @reader = Nokogiri::XML::Reader.from_io(io)
+    end
+
+    def self.new_with_open_file(filename, &block)
+      File.open(filename, 'r') do |file|
+        yield new(file)
+      end
+    end
+
+    # Codes used in their XML file format:
+    ARTIST_GENRE_RELATIONS = {
+      1 => :main,
+      2 => :secondary,
+      3 => :influenced_by
+    }
+
+    ASSOCIATION_TYPES = {
+      'A' => :similar,
+      'I' => :influenced_by,
+      'S' => :successor
+    }
+
+    include Enumerable
+    def get_all; self; end
+
+    def each
+      @reader.each do |node|
+        next unless node.name == 'artiste' && node.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT
+        doc = Nokogiri::XML(node.outer_xml)
+
+        # extract genres
+        genres = Hash.new {|h,k| h[k]=[]}
+        genres_and_relation = doc.xpath('//artiste/genres/genre').map do |node|
+          genre = Model::Genre.new(
+            :id   => to_i_or_nil(node.attr('id')),
+            :name => node.inner_text.strip
+          )
+          [genre, ARTIST_GENRE_RELATIONS[to_i_or_nil(node.attr('relation'))]]
+        end
+
+        genres_and_relation.uniq.each do |genre, relation|
+          genres[relation] << genre
+        end
+
+        # extract associations
+        associations = Hash.new {|h,k| h[k]=[]}
+        associated_artists_and_type = doc.xpath('//artiste/associes/associe').map do |node|
+          artist = Model::Artist.new({
+            :id => to_i_or_nil(node.attr('id_associe')),
+            :name => node.attr('nom_associe')
+          })
+          [artist, ASSOCIATION_TYPES[node.inner_text]]
+        end
+
+        associated_artists_and_type.uniq.each do |artist, type|
+          # FIXME track non-failing errors, rather than keeping quiet about it
+          associations[type] << artist unless invalid_artist?(artist)
+        end
+
+        yield Model::Artist.new({
+          :id        => to_i_or_nil(doc.xpath('//artiste').attr('id').value),
+          :name      => doc.xpath('//artiste/nom').inner_text,
+          :forename  => unless_empty(doc.xpath('//artiste/prenom').inner_text),
+          :real_name => unless_empty(doc.xpath('//artiste/nom_reel').inner_text),
+          :role      => unless_empty(doc.xpath('//artiste/role').inner_text),
+          :type      => unless_empty(doc.xpath('//artiste/type').inner_text),
+          :country   => unless_empty(doc.xpath('//artiste/pays').inner_text),
+          # not sure what the appropriate translation for resume vs texte_bio is here,
+          # but in data seen so far they are both the same and both HTML not plain text:
+          :summary_html          => unless_empty(doc.xpath('//artiste/resume').inner_text),
+          :image_filename        => unless_empty(doc.xpath('//artiste/image').inner_text),
+
+          :bio_html              => unless_empty(doc.xpath('//artiste/texte_bio').inner_text),
+          :main_genres           => genres[:main],
+          :secondary_genres      => genres[:secondary],
+          :influenced_by_genres  => genres[:influenced_by],
+          :similar_artists       => associations[:similar],
+          :influenced_by_artists => associations[:influenced_by],
+          :successor_artists     => associations[:successor]
+        })
+      end
+    end
+
+  private
+    def unless_empty(string)
+      string = string.strip
+      string unless string.empty?
+    end
+
+    # basic check that core artist properties are there and correct
+    def invalid_artist?(artist)
+      artist.name.nil? || artist.name.strip.empty? ||
+        artist.id.nil? || /[0-9]+/.match(artist.id.to_s).nil?
+    end
+
+    def to_i_or_nil(value)
+      /[0-9]+/.match(value.to_s) && value.to_i
+    end
+  end
+end

data/lib/music_story/repository/batch_sftp.rb

@@ -0,0 +1,178 @@
+require 'net/sftp'
+require 'music_story/model/batch'
+
+module MusicStory
+
+  # Gives access to whole batches of music story data that are kept somewhere
+  # on an sftp site somwhere that music story can constantly deliver new data.
+  # Once downloaded, this data can be accessed using the xml repository, or
+  # imported in to a local database
+  class Repository::BatchSFTP
+
+    # the presence of this file inside a batch directory tells us that the sender
+    # has finished sending it
+    DELIVERY_COMPLETE = 'delivery.complete'
+
+    # some sub dirs we use to manage the flow of data
+    DIR_PROCESSING = 'processing'
+    DIR_PROCESSED  = 'processed'
+
+    # memoised flag from sftp rename methods
+    RENAME_NATIVE = Net::SFTP::Constants::RenameFlags::NATIVE
+
+    def initialize(host, username, options={})
+      @host = host
+      @username = username
+      @options = options
+      @basedir = options[:basedir] || '/'
+      @batch_pattern = options[:batch_pattern] || 'music-story-data-*'
+      @logger = options[:logger] || Logger.new('/dev/null')
+    end
+
+    # start talking to the remote server, yielding the session to the block,
+    # which is closed after the block finishes executing.
+    # The block is yielded a wrapper object that lets you use the access methods
+    # in the repository, minus the first argument, for instance:
+    #    repo.connect do |session|
+    #      batch = session.new_batches.first
+    #      session.download(batch, '/tmp/dir')
+    #    end
+    def connect(&block)
+      return_result = nil
+      # the sftp.start method does not seem to return the last thing you execute
+      start_sftp_session do |sftp_session|
+        return_result = yield SessionWrapper.new(self, sftp_session)
+      end
+      return_result
+    end
+
+    def start_sftp_session(&block)
+      cnx_options = (@options[:net_sftp_options] || {}).
+        merge(:password => @options[:password])
+
+      @logger.info("Starting sftp session to '#{@host}'")
+      Net::SFTP.start(@host, @username, cnx_options) do |sftp_session|
+        block.call(sftp_session)
+      end.tap do
+        @logger.info("Finished sftp session to '#{@host}'")
+      end
+    end
+
+    #
+    # the following methods should be accessed by using connect, and not directly
+    #
+
+    # return a list of batches on the sftp that are in the processed state, i.e
+    # live in the `processed` directory
+    def processed_batches(w)
+      dir = join(@basedir, DIR_PROCESSED)
+      w.sftp.dir[dir, '*'].map do |entry|
+        Model::Batch.new(:path => join(dir, entry.name), :state => :processed)
+      end
+    end
+
+    # return a list of batches on the sftp site that are in the processing
+    # state, i.e live in the `processing` directory
+    def processing_batches(w)
+      dir = join(@basedir, DIR_PROCESSING)
+      w.sftp.dir[dir, '*'].map do |entry|
+        Model::Batch.new(:path => join(dir, entry.name), :state => :processing)
+      end
+    end
+
+    # return a list of all the batches on the sftp site that are ready to
+    # be downloaded or we can start processing them
+    def new_batches(w)
+      @logger.debug("Looking for new batches in remote dir '#@basedir' with pattern #@batch_pattern")
+      complete_dirs = w.sftp.dir[@basedir, @batch_pattern].select do |entry|
+        next if /\.log$/.match(entry.name) # skip log files (MSP#1915)
+
+        w.sftp.dir[join(@basedir, entry.name), DELIVERY_COMPLETE].any?.tap do |f|
+          if f
+            @logger.debug("  Found new batch: #{entry.name}")
+          else
+            @logger.debug("  Incomplete batch: #{entry.name}")
+          end
+        end
+      end
+
+      complete_dirs.map do |entry|
+        Model::Batch.new(:path => join(@basedir, entry.name),
+          :state => :new)
+      end
+    end
+
+    # download a batch.  Should work for a batch in any state
+    def download(w, batch, local_dir)
+      @logger.info("Downloading #{batch.path} to #{local_dir}...")
+      w.sftp.download!(batch.path, local_dir, :recursive => true) do |event, downloader, *args|
+        case event
+        when :open then
+          # args[0] : file metadata
+          @logger.debug "Starting download: #{args[0].remote} -> #{args[0].local} (#{args[0].size}) bytes"
+        when :close then
+          # args[0] : file metadata
+          @logger.debug "Finished download: #{args[0].remote}"
+        when :finish then
+          @logger.debug "Download complete"
+        end
+      end
+    end
+
+    # return true if there are any batches available
+    def new_available?(w)
+      new_batches(w).any?
+    end
+
+    # move a batch in to the processing state, moving its location on the remote
+    # fs
+    def mark_processing(w, batch)
+      new_name = join(@basedir, DIR_PROCESSING, File.basename(batch.path))
+      @logger.info("Marking #{batch} as processing")
+      @logger.debug("  moving #{batch.path} to #{new_name}")
+      w.sftp.rename(batch.path, new_name, RENAME_NATIVE)
+      batch.path = new_name
+      batch.state = :processing
+    end
+
+    # move a batch in to the processed state, moving its location on the remote
+    # fs
+    def mark_processed(w, batch, path_to_logfile=nil)
+      batch_basename = File.basename(batch.path)
+      new_name = join(@basedir, DIR_PROCESSED, batch_basename)
+      @logger.info("Marking #{batch} as processed")
+      @logger.debug("  moving #{batch.path} to #{new_name}")
+      w.sftp.rename(batch.path, new_name, RENAME_NATIVE)
+      batch.path = new_name
+      batch.state = :processed
+
+      if path_to_logfile
+        remote_logfile_path = join(@basedir, batch_basename + '.log')
+        uploader = w.sftp.upload!(path_to_logfile, remote_logfile_path)
+      end
+    end
+
+    private
+
+    # less chars ftw
+    def join(*args) ; File.join(*args) ; end
+  end
+
+  class Repository::BatchSFTP::SessionWrapper
+
+    attr_reader :sftp
+
+    def initialize(repository, sftp_session)
+      @repository = repository
+      @sftp = sftp_session
+    end
+
+    def method_missing(name, *args, &block)
+      @repository.send(name, *([self] + args), &block)
+    end
+
+    def respond_to?(name)
+      @repository.respond_to?(name)
+    end
+  end
+end

data/lib/music_story/repository/genre_sequel.rb

@@ -0,0 +1,7 @@
+module MusicStory
+  class Repository::GenreSequel < Persistence::Sequel::IdentitySetRepository
+    set_model_class Model::Genre
+    use_table :genres, :id_sequence => true
+    map_column :name
+  end
+end

data/lib/music_story/repository/sequel.rb

@@ -0,0 +1,66 @@
+module MusicStory
+  class Repository::Sequel
+    def initialize(db)
+      db = Sequel.connect(db) unless db.is_a?(Sequel::Database)
+      @db = db
+      @artist_repo = Repository::ArtistSequel.new(db)
+      @genre_repo  = Repository::GenreSequel.new(db)
+      [:similar_artists, :influenced_by_artists, :successor_artists].each do |prop|
+        @artist_repo.mapper(prop).target_repo = @artist_repo
+      end
+      [:main_genres, :secondary_genres, :influenced_by_genres].each do |prop|
+        @artist_repo.mapper(prop).target_repo = @genre_repo
+      end
+    end
+
+    attr_reader :artist_repo, :genre_repo, :db
+
+    def drop_tables!
+      [:genres, :artist_associations, :artist_genres, :artists].each do |table|
+        begin ; @db.drop_table(table) ; rescue ; end
+      end
+    end
+
+    def create_tables!
+      @db.create_table(:artist_associations, :ignore_index_errors=>true) do
+        Integer :from_artist_id, :null=>false
+        Integer :to_artist_id, :null=>false
+        String :relation, :size=>16
+
+        primary_key [:from_artist_id, :relation, :to_artist_id]
+
+        index [:to_artist_id], :name=>:to_artist_id
+      end
+
+      @db.create_table(:artist_genres, :ignore_index_errors=>true) do
+        Integer :artist_id, :null=>false
+        Integer :genre_id, :null=>false
+        String :relation, :size=>16
+
+        primary_key [:artist_id, :relation, :genre_id]
+
+        index [:genre_id], :name=>:genre_id
+      end
+
+      @db.create_table(:artists, :ignore_index_errors=>true) do
+        primary_key :id
+        String :name, :null=>false, :size=>255
+        String :forename, :size=>255
+        String :real_name, :size=>255
+        String :role, :size=>64
+        String :type, :size=>64
+        String :country, :size=>64
+        String :summary_html, :text=>true
+        String :bio_html, :text=>true
+        String :image_filename, :text=>true
+
+        index [:name], :name=>:name
+      end
+
+      @db.create_table(:genres) do
+        primary_key :id
+        String :name, :null=>false, :size=>255
+      end
+    end
+  end
+end

data/lib/music_story/utils/html_to_text.rb

@@ -0,0 +1,30 @@
+module MusicStory
+  # Converts HTML to plain text, converting <br>'s into newlines but
+  # stripping all other tags.
+  # May want to add support for other things like <p> into \n\n if they
+  # crop up; MusicStory only seems to use <br> though
+  class Utils::HTMLToText < Nokogiri::XML::SAX::Document
+    def self.convert(html)
+      doc = new
+      Nokogiri::HTML::SAX::Parser.new(doc).parse(html)
+      doc.to_s
+    end
+    
+    def initialize
+      @result = ''
+    end
+    
+    def characters(string)
+      @result << string
+    end
+    alias :cdata_block :characters
+    
+    def start_element(name, attributes=nil)
+      @result << "\n" if name.downcase == 'br'
+    end
+    
+    def to_s
+      @result.strip
+    end
+  end
+end

data/lib/music_story/utils/xml_to_db_importer.rb

@@ -0,0 +1,43 @@
+module MusicStory
+  class Utils::XMLToDBImporter
+    def self.import_file_into_db(filename, db, create_tables=false)
+      sequel_repos = Repository::Sequel.new(db)
+      sequel_repos.create_tables! if create_tables
+      results = Repository::ArtistXMLFile.new_with_open_file(filename) do |xml_repo|
+        new(xml_repo, sequel_repos).import
+      end
+
+      return results.merge(:sequel_repos => sequel_repos)
+    end
+
+    def initialize(xml_repo, sequel_repos)
+      @xml_repo = xml_repo
+      @sequel_repos = sequel_repos
+    end
+
+    def import
+      failures = []
+      successes = []
+
+      @xml_repo.each do |artist|
+        begin
+          @sequel_repos.artist_repo.transaction do
+            artist.all_associated_artists.each do |a|
+              @sequel_repos.artist_repo.store(a)
+            end
+            artist.all_genres.each do |g|
+              @sequel_repos.genre_repo.store(g)
+            end
+            @sequel_repos.artist_repo.store(artist)
+          end
+        rescue => e
+          failures << [artist, e]
+        end
+
+        successes << artist
+      end
+
+      {:successes => successes, :failures => failures}
+    end
+  end
+end

data/lib/music_story/version.rb

@@ -0,0 +1,4 @@
+module MusicStory
+  VERSION = '1.0.2'
+end
+

metadata

@@ -0,0 +1,197 @@
+--- !ruby/object:Gem::Specification 
+name: music_story
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 2
+  version: 1.0.2
+platform: ruby
+authors: 
+- Matthew Willson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-10-03 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sequel
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 43
+        segments: 
+        - 3
+        - 11
+        - 0
+        version: 3.11.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: persistence
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 17
+        segments: 
+        - 0
+        - 3
+        - 1
+        version: 0.3.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: thin_models
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 0
+        - 1
+        - 4
+        version: 0.1.4
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 1
+        - 5
+        - 0
+        version: 1.5.0
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: net-sftp
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: mock_sftp
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id008
+description: 
+email: 
+- matthew@playlouder.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/music_story/version.rb
+- lib/music_story/model/genre.rb
+- lib/music_story/model/batch.rb
+- lib/music_story/model/artist.rb
+- lib/music_story/utils/html_to_text.rb
+- lib/music_story/utils/xml_to_db_importer.rb
+- lib/music_story/repository/sequel.rb
+- lib/music_story/repository/artist_xml_file.rb
+- lib/music_story/repository/batch_sftp.rb
+- lib/music_story/repository/artist_sequel.rb
+- lib/music_story/repository/genre_sequel.rb
+- lib/music_story.rb
+- README.txt
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+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: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Wrapper code for the MusicStory data product
+test_files: []
+