bespoke 0.1.2 → 0.2.0

data/bespoke.gemspec

@@ -19,8 +19,11 @@ Gem::Specification.new do |gem|
 
   gem.add_development_dependency "bundler", ">= 1.0.0"
   gem.add_development_dependency "rspec", "~> 2.6"
+  gem.add_development_dependency "debugger"
 
   gem.add_dependency 'rake'
   gem.add_dependency 'docile'
   gem.add_dependency 'mustache'
+  gem.add_dependency 'sqlite3'
+  gem.add_dependency 'sequel'
 end

data/lib/bespoke.rb

@@ -1,39 +1,6 @@
 require "bespoke/version"
-require "bespoke/indexed_collection"
-require "bespoke/exportable"
 
-class Bespoke
-  attr_reader :collection, :exports
-
-  def initialize(hash, logger=nil)
-    @collection = IndexedCollection.new
-    hash["index"].each_pair do |name, column|
-      @collection.index name, column
-    end
-    @exports = {}
-    hash["export"].each_pair do |output_name, exportable_configs|
-      outputs = @exports[output_name] = []
-      exportable_configs.each do |config|
-        config.each_pair do |collection_name, attrs|
-          outputs << (export = Exportable.new(collection_name, logger))
-          (attrs["fields"] || {}).each_pair do |field, template|
-            export.field field, template
-          end
-          (attrs["joins"] || {}).each_pair do |join, template|
-            export.join join, template
-          end
-        end
-      end
-    end
-  end
-
-  def add(type, object)
-    @collection.add(type, object)
-  end
-
-  def export(name, &block)
-    @exports[name].each do |e|
-      e.export(@collection.collections, &block)
-    end
-  end
-end
+require "bespoke/template"
+require "bespoke/xsltproc"
+require "bespoke/projection"
+require "bespoke/join"

data/lib/bespoke/dsl.rb

@@ -1,9 +1,6 @@
 require "bespoke"
+require "docile"
 
-def indexed_collection(&block)
-  Docile.dsl_eval(Bespoke::IndexedCollection.new, &block)
-end
-
-def exportable(name, &block)
-  Docile.dsl_eval(Bespoke::Exportable.new(name), &block)
-end
+def projection(name, xpath_root=nil, &block)
+  Docile.dsl_eval(Bespoke::Projection.new(name, xpath_root), &block)
+end

data/lib/bespoke/join.rb

@@ -0,0 +1,57 @@
+require 'csv'
+require 'sequel'
+require 'logger'
+
+module Bespoke
+  class Join
+    def initialize(projections, log=nil)
+      @projections = projections
+      @log = log || Logger.new($stderr)
+    end
+
+    def database
+      return @database if @database
+      @database = Sequel.sqlite
+      create_tables
+      @database
+    end
+
+    def load_csv(tablename, filepath)
+      table = database[tablename.to_sym]
+      CSV.foreach(filepath, headers: true) do |row|
+        begin
+          table.insert(row.to_hash)
+        rescue Sequel::UniqueConstraintViolation => e
+          @log.warn "Unable to insert row #{row.inspect}: #{e}"
+        end
+      end
+    end
+
+    def query(sql)
+      database[sql]
+    end
+
+  protected
+
+    def create_tables
+      @projections.each { |prj| create_table(prj) }
+    end
+
+    def create_table(prj)
+      database.drop_table?(prj.name)
+      database.create_table(prj.name) do
+        prj.fields.each do |field|
+          if field.name.to_s == "ref_id"
+            column :ref_id, :string, :primary_key => true
+          else
+            column field.name, field.type
+          end
+        end
+      end
+    end
+
+  end
+end
+
+
+

data/lib/bespoke/projection.rb

@@ -0,0 +1,35 @@
+module Bespoke
+  class TypedField
+    attr_reader :name, :type, :xpath
+
+    # @name The name of the column or field
+    # @type The Sqlite3 type of the data
+    # @xpath The xpath query that retrieves the data from XML
+    def initialize(name, type, xpath)
+      @name = name
+      @type = type
+      @xpath = xpath
+    end
+  end
+
+  class Projection
+    attr_reader :name, :fields, :xpath_root
+
+    def initialize(name, xpath_root=nil)
+      @name = name.to_s
+      @xpath_root = xpath_root
+      @fields = []
+    end
+
+    def field(name, type=:string, xpath=nil)
+      @fields << TypedField.new(name, type, xpath)
+    end
+
+    def xpath_hash
+      pairs = @fields.map do |field|
+        [field.name, field.xpath]
+      end.flatten(1)
+      Hash[*pairs]
+    end
+  end
+end

data/lib/bespoke/template.rb

@@ -0,0 +1,45 @@
+require 'mustache'
+require 'tempfile'
+
+module Bespoke
+  class Template
+    attr_reader :template_file
+
+    def initialize(template_file)
+      @template_file = template_file
+    end
+
+    def render(object_type, projection)
+      fields = projection_fields(projection)
+      Mustache.render(template,
+        :object_type => object_type,
+        :projection => fields)
+    end
+
+  protected
+    def template
+      @template ||= Mustache::Template.new(File.read(@template_file))
+    end
+
+    def default_function
+      'escapeQuote'
+    end
+
+    def projection_pair(value)
+      value = Array(value)
+      [value.first, value[1] || default_function]
+    end
+
+    def projection_fields(projection)
+      projection.each_with_index.map do |(field, value), i|
+        selector, function = projection_pair(value)
+        {
+          :field    => field.to_s,
+          :function => function,
+          :selector => selector,
+          :last     => i == (projection.size - 1)
+        }
+      end
+    end
+  end
+end

data/lib/bespoke/version.rb

@@ -1,3 +1,3 @@
-class Bespoke
-  VERSION = '0.1.2' unless defined?(Bespoke::VERSION)
+module Bespoke
+  VERSION = '0.2.0' unless defined?(Bespoke::VERSION)
 end

data/lib/bespoke/xsltproc.rb

@@ -0,0 +1,83 @@
+require 'logger'
+require 'open3'
+require 'stringio'
+
+module Bespoke
+  class XSLTProc
+    def initialize(xslt, logger=nil)
+      @xslt_file = write_tmp_file(xslt)
+      @logger = logger || Logger.new(STDERR)
+    end
+
+    def write_tmp_file(xslt)
+      file = Tempfile.new('bespoke')
+      file.write(xslt)
+      return file.path
+    ensure
+      file.close
+    end
+
+    def transform(text)
+      out_file = StringIO.new("", 'w')
+      in_file = StringIO.new(text, 'r')
+      transform_file(in_file, out_file)
+      out_file.string
+    end
+
+    def transform_file(in_file, out_file)
+      cmd = ["xsltproc"]
+      cmd << @xslt_file
+
+      if in_file.respond_to?(:read)
+        cmd << "-" # use stdin
+      else
+        cmd << in_file
+      end
+
+      need_to_close_out_file = false
+      if out_file.is_a?(String)
+        need_to_close_out_file = true
+        out_file_handle = File.open(out_file, "a+")
+      elsif out_file.respond_to?(:write)
+        out_file_handle = out_file
+      else
+        raise "Need a file handle or file name for data transform destination"
+      end
+
+      threads = []
+      Open3.popen3(*cmd) do |stdin, stdout, stderr, wait_thr|
+        if in_file.respond_to?(:read)
+          # Send data
+          threads << Thread.new do
+            stdin.write in_file.read(2**16) until in_file.eof?
+            stdin.close
+          end
+        else
+          # No need to send data, we're passing in the filename
+          stdin.close
+        end
+
+        # Capture data
+        threads << Thread.new do
+          until (line = stdout.gets).nil? do
+            out_file_handle.write line
+          end
+        end
+
+        # Capture error messages
+        threads << Thread.new do
+          until (line = stderr.gets).nil? do
+            @logger.warn line
+          end
+        end
+
+        threads.each{ |t| t.join }
+        wait_thr.join
+      end
+    rescue SystemCallError => e
+      @logger.error e
+    ensure
+      out_file_handle.close if need_to_close_out_file
+    end
+  end
+end

data/spec/fixtures/books.xml

@@ -0,0 +1,12 @@
+<books>
+  <book>
+    <id>1</id>
+    <title>One</title>
+    <author>Deity</author>
+  </book>
+  <book>
+    <id>2</id>
+    <title>Two</title>
+    <author>Lovers</author>
+  </book>
+</books>

data/spec/fixtures/books_to_csv.xslt

@@ -0,0 +1,17 @@
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+
+  <xsl:output method="text" standalone="no"/>
+
+  <xsl:param name="delim" select="','" />
+  <xsl:param name="quote" select="'&quot;'" />
+  <xsl:param name="break" select="'&#xA;'" />
+
+  <xsl:template match="/books">
+    <xsl:for-each select="book">
+      <xsl:value-of select="$quote" /><xsl:value-of select="id"/><xsl:value-of select="$quote" /><xsl:value-of select="$delim" />
+      <xsl:value-of select="$quote" /><xsl:value-of select="title"/><xsl:value-of select="$quote" /><xsl:value-of select="$delim" />
+      <xsl:value-of select="$quote" /><xsl:value-of select="author"/><xsl:value-of select="$quote" /><xsl:value-of select="$break" />
+    </xsl:for-each>
+  </xsl:template>
+
+</xsl:stylesheet>

data/spec/fixtures/one.csv

@@ -0,0 +1,3 @@
+id,name
+1,bitcoin
+2,nxt

data/spec/fixtures/sif.student_personal.xslt

@@ -0,0 +1,101 @@
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:sif="http://www.sifinfo.org/infrastructure/2.x" xmlns:csv="csv:csv">
+  <xsl:output method="text" encoding="utf-8"/>
+
+  <xsl:param name="delim" select="','"/>
+  <xsl:param name="quote" select="'&quot;'"/>
+  <xsl:param name="break" select="'&#xA;'"/>
+
+  <xsl:template match="/">
+    <xsl:apply-templates select="//sif:StudentPersonal"/>
+  </xsl:template>
+
+
+  <xsl:template match="sif:StudentPersonal">
+    <xsl:value-of select="$quote"/>
+    <xsl:call-template name="escapeQuote">
+      <xsl:with-param name="text" select="@RefId"/>
+    </xsl:call-template>
+    <xsl:value-of select="$quote"/>
+    <xsl:value-of select="$delim"/>
+    <xsl:value-of select="$quote"/>
+    <xsl:call-template name="escapeQuote">
+      <xsl:with-param name="text" select="sif:LocalId"/>
+    </xsl:call-template>
+    <xsl:value-of select="$quote"/>
+    <xsl:value-of select="$delim"/>
+    <xsl:value-of select="$quote"/>
+    <xsl:call-template name="escapeQuote">
+      <xsl:with-param name="text" select="sif:Name/sif:FirstName"/>
+    </xsl:call-template>
+    <xsl:value-of select="$quote"/>
+    <xsl:value-of select="$delim"/>
+    <xsl:value-of select="$quote"/>
+    <xsl:call-template name="escapeQuote">
+      <xsl:with-param name="text" select="sif:Name[@Type='04']/sif:LastName"/>
+    </xsl:call-template>
+    <xsl:value-of select="$quote"/>
+    <xsl:value-of select="$delim"/>
+    <xsl:value-of select="$quote"/>
+    <xsl:call-template name="split-get-first">
+      <xsl:with-param name="text" select="sif:EmailList/sif:Email[@Type='Primary']"/>
+    </xsl:call-template>
+    <xsl:value-of select="$quote"/>
+    <xsl:value-of select="$break"/>
+  </xsl:template>
+
+  <!-- Function that prefixes any quotes (") in a string with a backslash -->
+  <xsl:template match="text/text()" name="escapeQuote">
+    <xsl:param name="text" select="."/>
+
+    <xsl:if test="string-length($text) > 0">
+     <xsl:value-of select="substring-before(concat($text, $quote), $quote)"/>
+
+     <xsl:if test="contains($text, $quote)">
+      <xsl:text>\</xsl:text><xsl:value-of select="$quote"/>
+      <xsl:call-template name="escapeQuote">
+        <xsl:with-param name="text" select="substring-after($text, $quote)"/>
+      </xsl:call-template>
+     </xsl:if>
+    </xsl:if>
+  </xsl:template>
+
+  <!-- Function to split on commas (or any separator), returning a list of elements -->
+  <xsl:template match="text/text()" name="split">
+      <xsl:param name="text" select="."/>
+      <xsl:param name="separator" select="','"/>
+      <xsl:choose>
+          <xsl:when test="not(contains($text, $separator))">
+            <xsl:call-template name="escapeQuote">
+              <xsl:with-param name="text" select="normalize-space($text)"/>
+            </xsl:call-template>
+          </xsl:when>
+          <xsl:otherwise>
+              <item>
+                  <xsl:value-of select="normalize-space(substring-before($text, $separator))"/>
+              </item>
+              <xsl:call-template name="split">
+                  <xsl:with-param name="text" select="substring-after($text, $separator)"/>
+              </xsl:call-template>
+          </xsl:otherwise>
+      </xsl:choose>
+  </xsl:template>
+
+  <!-- Function like "split", but returns just the first split element -->
+  <xsl:template match="text/text()" name="split-get-first">
+      <xsl:param name="text" select="."/>
+      <xsl:param name="separator" select="','"/>
+      <xsl:choose>
+          <xsl:when test="not(contains($text, $separator))">
+              <item>
+                  <xsl:value-of select="normalize-space($text)"/>
+              </item>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:call-template name="escapeQuote">
+              <xsl:with-param name="text" select="normalize-space(substring-before($text, $separator))"/>
+            </xsl:call-template>
+          </xsl:otherwise>
+      </xsl:choose>
+  </xsl:template>
+
+</xsl:stylesheet>

data/spec/fixtures/sif.xslt.mustache

@@ -0,0 +1,85 @@
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:sif="http://www.sifinfo.org/infrastructure/2.x" xmlns:csv="csv:csv">
+  <xsl:output method="text" encoding="utf-8"/>
+
+  <xsl:param name="delim" select="','"/>
+  <xsl:param name="quote" select="'&quot;'"/>
+  <xsl:param name="break" select="'&#xA;'"/>
+
+  <xsl:template match="/">
+    <xsl:apply-templates select="//{{object_type}}"/>
+  </xsl:template>
+
+
+  <xsl:template match="{{object_type}}">
+    {{!-- Loop through each projection field to generate an xslt transform for the column --}}
+    {{#projection}}
+    <xsl:value-of select="$quote"/>
+    <xsl:call-template name="{{function}}">
+      <xsl:with-param name="text" select="{{selector}}"/>
+    </xsl:call-template>
+    <xsl:value-of select="$quote"/>
+    {{^last}}
+    <xsl:value-of select="$delim"/>
+    {{/last}}
+    {{#last}}
+    <xsl:value-of select="$break"/>
+    {{/last}}
+    {{/projection}}
+  </xsl:template>
+
+  <!-- Function that prefixes any quotes (") in a string with a backslash -->
+  <xsl:template match="text/text()" name="escapeQuote">
+    <xsl:param name="text" select="."/>
+
+    <xsl:if test="string-length($text) > 0">
+     <xsl:value-of select="substring-before(concat($text, $quote), $quote)"/>
+
+     <xsl:if test="contains($text, $quote)">
+      <xsl:text>\</xsl:text><xsl:value-of select="$quote"/>
+      <xsl:call-template name="escapeQuote">
+        <xsl:with-param name="text" select="substring-after($text, $quote)"/>
+      </xsl:call-template>
+     </xsl:if>
+    </xsl:if>
+  </xsl:template>
+
+  <!-- Function to split on commas (or any separator), returning a list of elements -->
+  <xsl:template match="text/text()" name="split">
+      <xsl:param name="text" select="."/>
+      <xsl:param name="separator" select="','"/>
+      <xsl:choose>
+          <xsl:when test="not(contains($text, $separator))">
+            <xsl:call-template name="escapeQuote">
+              <xsl:with-param name="text" select="normalize-space($text)"/>
+            </xsl:call-template>
+          </xsl:when>
+          <xsl:otherwise>
+              <item>
+                  <xsl:value-of select="normalize-space(substring-before($text, $separator))"/>
+              </item>
+              <xsl:call-template name="split">
+                  <xsl:with-param name="text" select="substring-after($text, $separator)"/>
+              </xsl:call-template>
+          </xsl:otherwise>
+      </xsl:choose>
+  </xsl:template>
+
+  <!-- Function like "split", but returns just the first split element -->
+  <xsl:template match="text/text()" name="split-get-first">
+      <xsl:param name="text" select="."/>
+      <xsl:param name="separator" select="','"/>
+      <xsl:choose>
+          <xsl:when test="not(contains($text, $separator))">
+              <item>
+                  <xsl:value-of select="normalize-space($text)"/>
+              </item>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:call-template name="escapeQuote">
+              <xsl:with-param name="text" select="normalize-space(substring-before($text, $separator))"/>
+            </xsl:call-template>
+          </xsl:otherwise>
+      </xsl:choose>
+  </xsl:template>
+
+</xsl:stylesheet>

data/spec/fixtures/two.csv

@@ -0,0 +1,4 @@
+id,one_id,description
+1,1,Cryptocurrency
+2,1,Investment
+3,2,Alternate Cryptocurrency

data/spec/join_spec.rb

@@ -0,0 +1,44 @@
+require_relative 'spec_helper'
+
+describe Bespoke::Join do
+  let(:projections) {
+    [
+      projection(:one) {
+        field :id, :integer
+        field :name, :string
+      },
+      projection(:two) {
+        field :id, :integer
+        field :one_id, :integer
+        field :description, :string
+      }
+    ]
+  }
+  let(:join) { Bespoke::Join.new(projections) }
+
+  context "table 'one'" do
+    before { join.load_csv('one', fixture('one.csv')) }
+
+    it "loads csv" do
+      join.database[:one].count.should == 2
+    end
+
+    context "and table 'two'" do
+      before { join.load_csv('two', fixture('two.csv')) }
+
+      it "loads csv" do
+        join.database[:two].count.should == 3
+      end
+
+      it "joins" do
+        sql = "SELECT name, description FROM one LEFT JOIN two ON one.id = two.one_id"
+        join.query(sql).map { |row| row }.
+          should == [
+            {:name=>"bitcoin", :description=>"Cryptocurrency"},
+            {:name=>"bitcoin", :description=>"Investment"},
+            {:name=>"nxt", :description=>"Alternate Cryptocurrency"}
+          ]
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,3 +1,8 @@
 $LOAD_PATH << File.expand_path(File.join(*%w[ .. lib ]), File.dirname(__FILE__))
 
-require 'bespoke'
+require "bespoke"
+require "bespoke/dsl"
+
+def fixture(*fileparts)
+  File.join(File.dirname(__FILE__), 'fixtures', *fileparts)
+end

data/spec/template_spec.rb

@@ -0,0 +1,36 @@
+require_relative 'spec_helper'
+
+describe Bespoke::Template do
+  let(:projection) {
+    {
+      :ref_id     => "@RefId",
+      :local_id   => "sif:LocalId",
+      :first_name => "sif:Name/sif:FirstName",
+      :last_name  => "sif:Name[@Type='04']/sif:LastName",
+      :email      => ["sif:EmailList/sif:Email[@Type='Primary']", "split-get-first"]
+    }
+  }
+  let(:xslt_mustache) { fixture('sif.xslt.mustache') }
+  let(:xslt) { fixture('sif.student_personal.xslt') }
+  let(:tbuild) { Bespoke::Template.new(xslt_mustache) }
+  let(:fields) { tbuild.send(:projection_fields, projection) }
+
+  it "transforms" do
+    tbuild.render("sif:StudentPersonal", projection).should == File.read(xslt)
+  end
+
+  it "last element is the only element where 'last' is true" do
+    first = fields[0..-2].map{ |f| f[:last] }
+    first.all?{ |x| x == false }.should be_true
+    fields[-1][:last].should be_true
+  end
+
+  it "has optional function field" do
+    fields[-1].should == {
+      :field => "email",
+      :function => "split-get-first",
+      :selector => "sif:EmailList/sif:Email[@Type='Primary']",
+      :last => true
+    }
+  end
+end

data/spec/xsltproc_spec.rb

@@ -0,0 +1,24 @@
+require_relative 'spec_helper'
+
+describe Bespoke::XSLTProc do
+  let(:xslt) { File.read(fixture('books_to_csv.xslt')) }
+  let(:xml_file) { fixture('books.xml') }
+  let(:trans) { Bespoke::XSLTProc.new(xslt) }
+  let(:data) { %("1","One","Deity"\n"2","Two","Lovers"\n) }
+
+  it "transforms" do
+    text = File.read(xml_file)
+    trans.transform(text).should == data
+  end
+
+  it "can append to files" do
+    tmp = Tempfile.new('test')
+    2.times do
+      File.open(tmp.path, "a+") do |out_file|
+        trans.transform_file(xml_file, out_file)
+      end
+    end
+    output = File.read(tmp.path)
+    output.should == data * 2
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bespoke
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-10 00:00:00.000000000 Z
+date: 2014-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -43,6 +43,22 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -91,6 +107,38 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Bespoke does in-memory object joins using mustache templates
 email:
 - duane@instructure.com
@@ -101,14 +149,22 @@ files:
 - bespoke.gemspec
 - readme.md
 - lib/bespoke/dsl.rb
-- lib/bespoke/exportable.rb
-- lib/bespoke/indexed_collection.rb
+- lib/bespoke/join.rb
+- lib/bespoke/projection.rb
+- lib/bespoke/template.rb
 - lib/bespoke/version.rb
+- lib/bespoke/xsltproc.rb
 - lib/bespoke.rb
-- spec/bespoke_spec.rb
-- spec/exportable_spec.rb
-- spec/indexed_collection_spec.rb
+- spec/fixtures/books.xml
+- spec/fixtures/books_to_csv.xslt
+- spec/fixtures/one.csv
+- spec/fixtures/sif.student_personal.xslt
+- spec/fixtures/sif.xslt.mustache
+- spec/fixtures/two.csv
+- spec/join_spec.rb
 - spec/spec_helper.rb
+- spec/template_spec.rb
+- spec/xsltproc_spec.rb
 homepage: 
 licenses: []
 post_install_message: 
@@ -134,8 +190,14 @@ signing_key:
 specification_version: 3
 summary: Bespoke does in-memory object joins using mustache templates
 test_files:
-- spec/bespoke_spec.rb
-- spec/exportable_spec.rb
-- spec/indexed_collection_spec.rb
+- spec/fixtures/books.xml
+- spec/fixtures/books_to_csv.xslt
+- spec/fixtures/one.csv
+- spec/fixtures/sif.student_personal.xslt
+- spec/fixtures/sif.xslt.mustache
+- spec/fixtures/two.csv
+- spec/join_spec.rb
 - spec/spec_helper.rb
+- spec/template_spec.rb
+- spec/xsltproc_spec.rb
 has_rdoc: 

data/lib/bespoke/exportable.rb

@@ -1,82 +0,0 @@
-require 'csv'
-require 'docile'
-require 'mustache'
-require 'logger'
-
-class Bespoke
-  class Error < StandardError; end
-  MissingTable = Class.new(Error)
-
-  class Exportable
-    attr_accessor :name, :fields, :joins
-
-    def initialize(name, logger=nil)
-      @name = name.to_sym
-      @fields = {}
-      @joins = {}
-      @helpers = {}
-      @logger = logger || Logger.new(STDERR)
-    end
-
-    class HelperClass
-      def initialize(helpers, context)
-        @helpers, @context = helpers, context
-      end
-
-      def has_key?(key)
-        @helpers.has_key?(key) ||
-        @context.has_key?(key)
-      end
-
-      def [](key)
-        if @helpers.has_key?(key)
-          @helpers[key].call(@context)
-        elsif @context.has_key?(key)
-          @context[key]
-        else
-          super(key)
-        end
-      end
-    end
-
-    def headers
-      @fields.keys
-    end
-
-    def helper(name, &block)
-      @helpers[name] = block
-    end
-
-    def field(name, template_string)
-      fields[name] = Mustache::Template.new(template_string)
-    end
-
-    def join(name, key)
-      joins[name] = key
-    end
-
-    def export(hashes={}, &block)
-      raise "hashes missing #{@name.inspect} (of: #{hashes.keys.inspect})" unless hashes.has_key?(@name)
-      hashes[@name].map do |main_key, row|
-        context = { @name => row }
-        context[:helper] = HelperClass.new(@helpers, context)
-        @joins.each_pair do |join_name, key|
-          if other_table = hashes[join_name.to_sym]
-            if other_table.has_key?(row[key])
-              context[join_name.to_sym] = other_table[row[key]]
-            else
-              @logger.warn "Expected foreign key #{key} with value #{row[key]} in table #{join_name} (#{row.inspect})"
-            end
-          else
-            raise MissingTable, "Expected #{join_name}"
-          end
-        end
-        fields.map do |name, template|
-          Mustache.render(template, context)
-        end.tap do |output_row|
-          yield output_row if block_given?
-        end
-      end
-    end
-  end
-end

data/lib/bespoke/indexed_collection.rb

@@ -1,45 +0,0 @@
-require 'docile'
-
-class Bespoke
-  class IndexedCollection
-    attr_reader :collections
-    
-    def initialize
-      @index_columns = {}
-      @collections = {}
-    end
-
-    def proc_for_key(key)
-      return Proc.new{ |x| nil } unless key
-      key = key.first if key.is_a?(Array) and key.size == 1
-      if key.is_a?(Array)
-        Proc.new{ |x| key.map{ |k| (x[k] rescue x.send(k)) } }
-      else
-        Proc.new{ |x| (x[key] rescue x.send(key)) }
-      end
-    end
-
-    def index(collection_name, index_key_method=nil, &block)
-      col_sym = collection_name.to_sym
-      @index_columns[col_sym] = block || proc_for_key(index_key_method)
-      @collections[col_sym] = {}
-    end
-
-    def add(collection_name, object)
-      col_sym = collection_name.to_sym
-      key_from_object = @index_columns[col_sym]
-      key = key_from_object.call(object)
-      begin
-        @collections[col_sym][key] = object
-      rescue NoMethodError
-        raise "Can't find collection #{col_sym} with key #{key}"
-      end
-    end
-
-    def find(collection_name, key)
-      if collection = @collections[collection_name.to_sym]
-        collection[key]
-      end
-    end
-  end
-end

data/spec/bespoke_spec.rb

@@ -1,112 +0,0 @@
-require_relative 'spec_helper'
-
-describe Bespoke do
-  let(:data) {
-    {
-      "student" => [
-        { "id" => 1, "first_name" => "Eric",  "last_name" => "Adams" },
-        { "id" => 2, "first_name" => "Duane", "last_name" => "Johnson" },
-        { "id" => 3, "first_name" => "Ken",   "last_name" => "Romney" }
-      ],
-      "staff" => [
-        { "id" => 1, "last_name" => "Baxter", "school_id" => 1 },
-        { "id" => 2, "last_name" => "Summer", "school_id" => 2 }
-      ],
-      "school" => [
-        { "id" => 1, "district" => "North" },
-        { "id" => 2, "district" => "East" },
-        { "id" => 3, "district" => "South" }
-      ]
-    }
-  }
-  let(:config) {
-    {
-      "index" => {
-        "student" => ["id"],
-        "staff"   => ["id"],
-        "school"  => ["id"]
-      },
-      "export" => {
-        "users" => [
-          {
-            "student" => {
-              "fields" => {
-                "user_id" => "{{student.id}}",
-                "name"    => "{{student.first_name}} {{student.last_name}}"
-              }
-            }
-          },
-          {
-            "staff" => {
-              "fields" => {
-                "user_id" => "{{staff.id}}",
-                "name"    => "{{school.district}} Professor {{staff.last_name}}"
-              },
-              "joins" => {
-                "school" => "school_id"
-              }
-            }
-          }
-        ],
-        "schools" => [
-          {
-            "school" => {
-              "fields" => {
-                "school_id" => "{{school.id}}",
-                "district"  => "D:{{school.district}}"
-              }
-            }
-          }
-        ]
-      }
-    }
-  }
-  let(:bespoke) { Bespoke.new(config) }
-
-  it "initializes" do
-    Bespoke.new(config)
-  end
-
-  context "with loaded data" do
-    before do
-      data.each_pair do |type, rows|
-        rows.each do |row|
-          bespoke.add type, row
-        end
-      end
-    end
-
-    it "creates a collection in memory" do
-      bespoke.collection.collections.should == {
-        :student => {
-          1 => {"id"=>1, "first_name"=>"Eric", "last_name"=>"Adams"},
-          2 => {"id"=>2, "first_name"=>"Duane", "last_name"=>"Johnson"},
-          3 => {"id"=>3, "first_name"=>"Ken", "last_name"=>"Romney"}
-        },
-        :staff => {
-          1 => {"id"=>1, "last_name"=>"Baxter", "school_id"=>1},
-          2 => {"id"=>2, "last_name"=>"Summer", "school_id"=>2}
-        },
-        :school => {
-          1 => {"id"=>1, "district"=>"North"},
-          2 => {"id"=>2, "district"=>"East"},
-          3 => {"id"=>3, "district"=>"South"}
-        }
-      }
-    end
-
-    it "exports" do
-      rows = []
-      bespoke.export("users") do |row|
-        rows << row
-      end
-      rows.should == [
-        ["1", "Eric Adams"],
-        ["2", "Duane Johnson"],
-        ["3", "Ken Romney"],
-        ["1", "North Professor Baxter"],
-        ["2", "East Professor Summer"]
-      ]
-    end
-  end
-end

data/spec/exportable_spec.rb

@@ -1,74 +0,0 @@
-require_relative 'spec_helper'
-require 'logger'
-require 'stringio'
-
-describe Bespoke::Exportable do
-  let(:logger) { nil }
-  let(:export) { Bespoke::Exportable.new(:test, logger) }
-  let(:test_data) {
-    {
-      1 => {:one => 1, :two => 2},
-      2 => {:one => 5, :two => 10}
-    }
-  }
-
-  before do
-    export.field(:column, "{{test.one}}-{{test.two}}")
-  end
-
-  it "initializes" do
-    export
-  end
-
-  it "exports templated rows" do
-    data = export.export(:test => test_data)
-    data.should == [["1-2"], ["5-10"]]
-  end
-
-  context "helper methods" do
-    it "can be declared" do
-      export.field(:helped, "{{helper.helper_method}}")
-      export.helper(:helper_method) { |row| "help!" }
-
-      data = export.export(:test => test_data)
-      data.should == [["1-2", "help!"], ["5-10", "help!"]]
-    end
-
-    it "has access to row data" do
-      export.field(:helped, "{{helper.fallback}}")
-      export.helper(:fallback) do |row|
-        row[:test][:one] || row[:test][:two]
-      end
-
-      data = export.export(:test =>
-        {
-          1 => {:two => 2},
-          2 => {:one => 5, :two => 10}
-        }
-      )
-      data.should == [["-2", "2"], ["5-10", "5"]]
-    end
-  end
-
-  context "logging" do
-    let(:output) { StringIO.new }
-    let(:logger) { Logger.new(output) }
-
-    it "logs missing join data" do
-      export.field(:column, "{{test.id}}-{{test.value}}")
-      export.join(:user, :id)
-      data = export.export({
-        :user => {
-          1 => {:test_id => 1, :name => "Duane"},
-          2 => {:test_id => 2, :name => "Ken"},
-        },
-        :test => {
-          1 => {:id => 1, :value => 2},
-          2 => {:id => 5, :value => 10}
-        }
-      })
-      log_msg = output.string.split(' : ')[1]
-      log_msg.should == "Expected foreign key id with value 5 in table user ({:id=>5, :value=>10})\n"
-    end
-  end
-end

data/spec/indexed_collection_spec.rb

@@ -1,7 +0,0 @@
-require_relative 'spec_helper'
-
-describe Bespoke::IndexedCollection do
-  it "initializes" do
-    Bespoke::IndexedCollection.new
-  end
-end