bespoke 0.2.0 → 0.2.1

data/lib/bespoke/export/filter/string_literal.rb

@@ -0,0 +1,16 @@
+module Bespoke
+  class Export
+    class Filter
+      class StringLiteral
+        def self.match?(string)
+          string.start_with?("'") && string.end_with?("'")
+        end
+
+        def self.extract_from(string)
+          unquoted_literal = string[1..-2]
+          Sequel.expr(unquoted_literal)
+        end
+      end
+    end
+  end
+end

data/lib/bespoke/join.rb

@@ -11,7 +11,12 @@ module Bespoke
 
     def database
       return @database if @database
-      @database = Sequel.sqlite
+      @database = Sequel.sqlite(nil, after_connect: ->(connection) {
+        connection.create_function('concat_ws', -1) {|proxy, *args|
+          separator = args.pop
+          proxy.result = args.compact.join(separator)
+        }
+      })
       create_tables
       @database
     end
@@ -27,9 +32,15 @@ module Bespoke
       end
     end
 
-    def query(sql)
+    def [](sql)
       database[sql]
     end
+    alias_method :query, :[]
+
+    def projection_named(table_name)
+      table_symbol = database.tables.find{|t| t.to_s == table_name.to_s}
+      table_symbol.nil? ? nil : database[table_symbol]
+    end
 
   protected
 
@@ -39,17 +50,13 @@ module Bespoke
 
     def create_table(prj)
       database.drop_table?(prj.name)
+      prj.ensure_primary_key!
       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
+          column field.name, field.type, field.column_options
         end
       end
     end
-
   end
 end
 

data/lib/bespoke/mustache.rb

@@ -0,0 +1,17 @@
+require 'mustache'
+
+if RUBY_VERSION >= '2.0'
+  class Mustache
+    TABLE_FOR_ESCAPE_HTML = {
+      '&' => '&',
+      '"' => '"',
+      '<' => '&lt;',
+      '>' => '&gt;',
+    }
+    REGEXP_FOR_ESCAPE_HTML = Regexp.new("[#{ TABLE_FOR_ESCAPE_HTML.keys.map{|k| Regexp.escape(k) }.join  }]")
+
+    def escapeHTML(string)
+      string.gsub(REGEXP_FOR_ESCAPE_HTML, TABLE_FOR_ESCAPE_HTML)
+    end
+  end
+end

data/lib/bespoke/projection.rb

@@ -1,28 +1,20 @@
-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
+require_relative 'typed_field'
 
+module Bespoke
   class Projection
     attr_reader :name, :fields, :xpath_root
 
-    def initialize(name, xpath_root=nil)
+    class NoPrimaryKeyError < Bespoke::Error; end
+
+    def initialize(name, xpath_root=nil, &block)
       @name = name.to_s
       @xpath_root = xpath_root
       @fields = []
+      handle_init_block(&block) if block_given?
     end
 
-    def field(name, type=:string, xpath=nil)
-      @fields << TypedField.new(name, type, xpath)
+    def field(name, type=:string, options_or_xpath = {})
+      @fields << TypedField.new(name, type, options_or_xpath)
     end
 
     def xpath_hash
@@ -31,5 +23,27 @@ module Bespoke
       end.flatten(1)
       Hash[*pairs]
     end
+
+    def ensure_primary_key!
+      return if @fields.any?(&:primary_key?)
+
+      ref_id = @fields.find{|f| f.name == :ref_id }
+      if ref_id
+        warn 'Implicit primary key of ref_id detected, this feature is deprecated and will be removed soon.'
+        ref_id.make_primary_key!
+      else
+        raise NoPrimaryKeyError, "No primary key specified or implied for projection #{ self.name }"
+      end
+    end
+
+    private
+
+    def handle_init_block(&block)
+      if block.arity == 1
+        block.call(self)
+      else
+        instance_exec(&block)
+      end
+    end
   end
-end
+end

data/lib/bespoke/template.rb

@@ -1,4 +1,4 @@
-require 'mustache'
+require_relative './mustache'
 require 'tempfile'
 
 module Bespoke
@@ -42,4 +42,4 @@ module Bespoke
       end
     end
   end
-end
+end

data/lib/bespoke/typed_field.rb

@@ -0,0 +1,30 @@
+module Bespoke
+  class TypedField
+    attr_reader :name, :type, :column_options, :xpath
+
+    # @name The name of the column or field
+    # @type The Sqlite3 type of the data
+    # @options_or_xpath The options to be supplied to Sequel when generating the column
+    #   along with the xpath used to extract the data from XML
+    def initialize(name, type, options_or_xpath = {})
+      @name = name
+      @type = type
+      if options_or_xpath.is_a? Hash
+        @xpath = options_or_xpath.delete(:xpath)
+        @column_options = options_or_xpath
+      else
+        @xpath = options_or_xpath
+        @column_options = {}
+        warn "Passing a string or array as the xpath is deprecated, please supply an options hash with an xpath key at: #{ caller[1] }"
+      end
+    end
+
+    def make_primary_key!
+      column_options[:primary_key] = true
+    end
+
+    def primary_key?
+      !!column_options[:primary_key]
+    end
+  end
+end

data/lib/bespoke/version.rb

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

data/spec/fixtures/sif.student_personal.xslt

@@ -98,4 +98,4 @@
       </xsl:choose>
   </xsl:template>
 
-</xsl:stylesheet>
+</xsl:stylesheet>

data/spec/fixtures/sif.xslt.mustache

@@ -82,4 +82,4 @@
       </xsl:choose>
   </xsl:template>
 
-</xsl:stylesheet>
+</xsl:stylesheet>

data/spec/lib/bespoke/export/filter/function_call_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+module Bespoke
+  class Export::Filter
+    describe FunctionCall do
+      describe '#function' do
+        it 'must correctly identify the function specified when no args are present' do
+          call = FunctionCall.new('rand()')
+          expect(call.function).to eq 'rand'
+        end
+
+        it 'must correctly identify the function specified when an argument is being passed' do
+          call = FunctionCall.new("foo_bar(0)")
+          expect(call.function).to eq 'foo_bar'
+        end
+
+        it 'must correctly identify the function specified when multiple arguments are being supplied' do
+          call = FunctionCall.new("foo_bar(0, 2, foo)")
+          expect(call.function).to eq 'foo_bar'
+        end
+      end
+
+      describe '#arguments' do
+        it 'must return an empty array when no arguments are specified for the function being called' do
+          call = FunctionCall.new('rand()')
+          expect(call.arguments).to eq []
+        end
+
+        it 'must return an array with a single string when a single argument is supplied' do
+          call = FunctionCall.new("foo_bar(0)")
+          expect(call.arguments).to eq ['0']
+        end
+
+        it 'must return an array with the specified values when multiple values are supplied' do
+          call = FunctionCall.new("foo_bar(0, foo, bar)")
+          expect(call.arguments).to eq %w{0 foo bar}
+        end
+
+        it 'must reutrn the correct values when the whitespace is inconsistent' do
+          call = FunctionCall.new("foo_bar(\t 0, foo,bar     )")
+          expect(call.arguments).to eq %w{0 foo bar}
+        end
+      end
+
+      describe '#extract' do
+        it 'must return a Sequel function node for most inputs' do
+          call = FunctionCall.new("foo_bar(0, foo, bar)")
+          extracted_call = call.extract
+          expect(extracted_call).to be_a Sequel::SQL::Function
+          expect(extracted_call.name).to eq 'FOO_BAR'
+          expect(extracted_call.args).to eq %w{0 foo bar}
+        end
+
+        it 'must specially handle a function named random_str' do
+          call = FunctionCall.new("random_str(4)")
+          extracted_call = call.extract
+          expect(extracted_call).to be_a Sequel::LiteralString
+          expect(extracted_call.to_s).to eq 'LOWER(HEX(RANDOMBLOB(4)))'
+        end
+      end
+
+      describe "custom functions" do
+        it "can be created" do
+          call = FunctionCall.new("myfn('hi')", :myfn => ->(args) { "LOWER(#{args.first})" })
+          extracted_call = call.extract
+          expect(extracted_call).to be_a Sequel::LiteralString
+          expect(extracted_call.to_s).to eq "LOWER('hi')"
+        end
+      end
+    end
+  end
+end

data/spec/lib/bespoke/export/filter/identifier_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'bespoke/export/filter/identifier'
+
+module Bespoke
+  class Export::Filter
+    describe Identifier do
+      describe '#sequel_identifier' do
+        it 'must return an unqualified identifer with the right content for an unqualified column' do
+          identifier = Identifier.new('id')
+          sequel_identifier = identifier.sequel_identifier
+          expect(sequel_identifier).to be_a Sequel::SQL::Identifier
+          expect(sequel_identifier.value).to eq 'id'
+        end
+
+        it 'must return a qualified identifier with the right conent for a qualified column' do
+          identifier = Identifier.new('students.id')
+          sequel_identifier = identifier.sequel_identifier
+          expect(sequel_identifier).to be_a Sequel::SQL::QualifiedIdentifier
+          expect(sequel_identifier.table).to eq 'students'
+          expect(sequel_identifier.column).to eq 'id'
+        end
+      end
+
+      describe '#parts' do
+        it 'must correctly handle identifiers surrounded by arbitrary whitespace' do
+          identifier = Identifier.new("\t students.id    ")
+          expect(identifier.parts).to eq({table: 'students', column: 'id'})
+        end
+
+        it 'must take an unqualified unquoted column identifier and return the correct values' do
+          identifier = Identifier.new('id')
+          expect(identifier.parts).to eq({table: nil, column: 'id'})
+        end
+
+        it 'must take a qualified unquoted column identifier and return the correct values' do
+          identifier = Identifier.new('students.id')
+          expect(identifier.parts).to eq({table: 'students', column: 'id'})
+        end
+
+        it 'must take an unqualified quoted column identifier and return the correct values' do
+          identifier = Identifier.new('"name.first_name"')
+          expect(identifier.parts).to eq({table: nil, column: 'name.first_name'})
+        end
+
+        it 'must take a qualified column identifier with the column name quoted and return the correct values' do
+          identifier = Identifier.new('students."name.first_name"')
+          expect(identifier.parts).to eq({table: 'students', column: 'name.first_name'})
+        end
+
+        it 'must take a qualified column identifier with the table name quoted and return the correct values' do
+          identifier = Identifier.new('"students".name')
+          expect(identifier.parts).to eq({table: 'students', column: 'name'})
+        end
+
+        it 'must take a qualified, fully quoted column identifier and return the correct values' do
+          identifier = Identifier.new('"students"."name.first_name"')
+          expect(identifier.parts).to eq({table: 'students', column: 'name.first_name'})
+        end
+      end
+    end
+  end
+end

data/spec/lib/bespoke/export/filter/select_template_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+module Bespoke
+  class Export::Filter
+    describe SelectTemplate do
+      let(:join) { basic_join }
+      let(:db) { join.database }
+      let(:table) { db[:two] }
+      let(:template) { SelectTemplate.new(:course_id, '') }
+
+      describe '#compile' do
+        let(:result) { template.compile }
+        let(:sql) { table.select(result).sql }
+
+        it 'must build an aliased expression with the correct alias' do
+          expect(result.aliaz).to eq :course_id
+        end
+
+        it 'must interpret a symbol as a column specification' do
+          template.template_string = :id
+          expect(sql).to include %q[`id` AS 'course_id']
+        end
+
+        it 'must interpret a symbol with double underscores as a qualified column specification' do
+          template.template_string = :sections__id
+          expect(sql).to include %q[`sections`.`id` AS 'course_id']
+        end
+
+        it 'must interpret unqualified templates correctly' do
+          template.template_string = '<id>'
+          expect(sql).to include %q[`id` AS 'course_id']
+        end
+
+        it 'must interpret qualified templates correctly' do
+          template.template_string = '<sections.id>'
+          expect(sql).to include %q[`sections`.`id` AS 'course_id']
+        end
+
+        it 'must interpret a template with multiple values as neeing to be caalesced' do
+          template.template_string = '<id | foo>'
+          expect(sql).to include %q[COALESCE(`id`, `foo`) AS 'course_id']
+        end
+
+        it 'must interepret a template in single quotes as a literal value' do
+          template.template_string = "<'foo'>"
+          expect(sql).to include %q['foo' AS 'course_id']
+        end
+
+        it 'must coalesce a identifer and a literal string correctly' do
+          template.template_string = "<id | 'foo'>"
+          expect(sql).to include %q[COALESCE(`id`, 'foo') AS 'course_id']
+        end
+
+        it 'must interepret a default value of random_str(\d+) correctly' do
+          template.template_string = '<courses.enrollment_count | random_str(6)>'
+          expect(sql).to include %q[COALESCE(`courses`.`enrollment_count`, LOWER(HEX(RANDOMBLOB(6)))) AS 'course_id']
+        end
+
+        it 'must interpret a template consisting of a column and a prepended string correctly' do
+          template.template_string = 'course_<courses.id>'
+          expect(sql).to include %q[('course_' || `courses`.`id`) AS 'course_id']
+        end
+
+        it 'must interpret a template consisting of a columna and an appended string correctly' do
+          template.template_string = '<students.student_username>@foo.k12.mo.us'
+          expect(sql).to include %q[(`students`.`student_username` || '@foo.k12.mo.us') AS 'course_id']
+        end
+
+        it 'must interpret complex strings with column templates interpolated inside them' do
+          template.template_string = 'course_<courses.id>_record'
+          expect(sql).to include %q[('course_' || `courses`.`id` || '_record') AS 'course_id']
+        end
+
+        it 'must interpret 2 element joined array selecte template strings correctly' do
+          template.template_string = '<section_id>-<term_id>'
+          expect(sql).to include %q[concat_ws(`section_id`, `term_id`, '-') AS 'course_id']
+        end
+
+        it 'must interpret joined array select template strings correctly' do
+          template.template_string = '<section_id>-<term_id>-<staff_id>'
+          expect(sql).to include %q[concat_ws(`section_id`, `term_id`, `staff_id`, '-') AS 'course_id']
+        end
+
+        it 'must extract the correct separator from joined array template strings' do
+          template.template_string = '<section_id>=+=<term_id>=+=<staff_id>'
+          expect(sql).to include %q[concat_ws(`section_id`, `term_id`, `staff_id`, '=+=') AS 'course_id']
+        end
+
+        context "with custom function" do
+          let(:template) {
+            SelectTemplate.new(:course_id, '', :myfn => ->(args) { "MYFN()" })
+          }
+
+          it 'does it' do
+            template.template_string = '<myfn(5)>'
+            expect(sql).to include %q[MYFN()]
+          end
+        end
+      end
+    end
+  end
+end