mkxms-mssql 1.0.0

data/lib/mkxms/mssql/unique_constraint_handler.rb

@@ -0,0 +1,32 @@
+require 'mkxms/mssql/keylike_constraint_helper'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class UniqueConstraint < KeylikeConstraint
+    SQL_CONSTRAINT_TYPE = 'UNIQUE'
+    
+    def sql_constraint_type
+      SQL_CONSTRAINT_TYPE
+    end
+  end
+  
+  class UniqueConstraintHandler
+    def initialize(constraints, node)
+      a = node.attributes
+      
+      @uconst = UniqueConstraint.new(a).tap do |c|
+        constraints << c
+      end
+    end
+    
+    def handle_column_element(parse)
+      a = parse.node.attributes
+      
+      raise UnsupportedFeatureError.new("Unique constraints may not specify included columns (#{@uconst.qualified_table})") if a['included']
+      @uconst.columns << IndexColumn.new(a['name'], a['desc'] ? :descending : :ascending)
+    end
+    
+    # TODO: Handle partitioned unique constraints
+  end
+end

data/lib/mkxms/mssql/utils.rb

@@ -0,0 +1,83 @@
+require 'tsort'
+
+module Mkxms; end
+module Mkxms::Mssql; end
+
+module Mkxms::Mssql::Utils
+  INVALID_NAME_CHAR = /[^A-Za-z0-9_]/
+  
+  module FlagsQueries
+    def flags_query(*syms, flags: :flags)
+      syms.each do |sym|
+        define_method((sym.to_s + '?').to_sym) {send(flags).include? sym}
+      end
+    end
+  end
+  
+  module InitializedAttributes
+    def attr_init(*syms, &blk)
+      raise "No block given for initialization of attr_init" unless blk
+      
+      syms.each do |sym|
+        inst_var = "@#{sym}".to_sym
+        define_method(sym) do
+          instance_variable_get(inst_var) ||
+          instance_variable_set(inst_var, blk[])
+        end
+      end
+    end
+  end
+  
+  module SchemaQualifiedName
+    def qualified_name
+      [schema, name].join('.')
+    end
+  end
+  
+  class NameRefGraph
+    include TSort
+    
+    def initialize(items, children: :children)
+      @items = items
+      @children_message = children
+    end
+    
+    def tsort_each_node(&blk)
+      @items.each(&blk)
+    end
+    
+    def tsort_each_child(item, &blk)
+      item.send(@children_message).each(&blk)
+    end
+  end
+end
+
+class << Mkxms::Mssql::Utils
+  def code_sym_for(s)
+    s.gsub(self::INVALID_NAME_CHAR, '_').downcase.to_sym
+  end
+  
+  def unquoted_name(s)
+    return s unless s[0] == '[' && s[-1] == ']'
+    return s[1...-1].gsub(']]', ']')
+  end
+  
+  def newline_prefixed(s)
+    "\n" + s
+  end
+  
+  def chars_to_tab(prev, tab_width: 4)
+    (prev.chars.length + 3) % 4 + 1
+  end
+  
+  def expand_tabs(s, tab_width: 4)
+    return s unless s.include? "\t"
+    
+    s.each_line.map do |l|
+      while l.include? "\t"
+        l.sub!("\t") {|m| ' ' * chars_to_tab($`, tab_width: tab_width)}
+      end
+      l
+    end.join('')
+  end
+end

data/lib/mkxms/mssql/version.rb

@@ -0,0 +1,5 @@
+module Mkxms
+  module Mssql
+    VERSION = "1.0.0"
+  end
+end

data/lib/mkxms/mssql/view_handler.rb

@@ -0,0 +1,58 @@
+require 'mkxms/mssql/access_object_definition'
+require 'mkxms/mssql/property_handler'
+require 'mkxms/mssql/utils'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class View
+    include ExtendedProperties, Property::Hosting, Property::SchemaScoped
+    include Utils::SchemaQualifiedName
+    
+    SQL_OBJECT_TYPE = 'VIEW'
+    
+    def initialize(attrs)
+      @schema = attrs['schema']
+      @name = attrs['name']
+      @definition = ''
+      @references = []
+    end
+    
+    attr_accessor :schema, :name
+    attr_reader :definition, :references
+    
+    def to_sql
+      mvdef = AccessObjectDefinition.replace_object_name(definition, "[{filename}]")
+      ([mvdef] + extended_properties_sql).join("\n")
+    end
+  end
+
+  class ViewHandler
+    include PropertyHandler::ElementHandler
+    
+    def initialize(views, node)
+      a = node.attributes
+      
+      @view = View.new(a).tap do |v|
+        views << v
+      end
+    end
+    
+    def extended_properties
+      @view.extended_properties
+    end
+    
+    def handle_definition_element(parse); end
+    
+    def handle_references_element(parse)
+      @view.references << %w[schema name].map {|k| parse.node.attributes[k]}.join('.')
+    end
+    
+    def handle_text(text, parent_element)
+      case [parent_element.namespace, parent_element.name]
+      when ['', 'definition']
+        @view.definition << text
+      end
+    end
+  end
+end

data/lib/mkxms/mssql.rb

@@ -0,0 +1,62 @@
+require "optparse"
+require "ostruct"
+require "pathname"
+require "rexml/document"
+
+module Mkxms
+  module Mssql
+    def self.parse_argv(argv = ARGV.dup)
+      options = OpenStruct.new
+      optparser = OptionParser.new do |flags|
+        flags.banner = "Usage: #{File.basename($0)} [<option> [<option> ...]] [DB_DESCRIPTION_FILE]"
+        flags.separator ''
+        flags.separator 'Options:'
+        
+        options.schema_dir = Pathname.pwd
+        flags.on('-o', '--outdir=SCHEMA_DIR', "Output in SCHEMA_DIR") do |schema_dir|
+          options.schema_dir = Pathname(schema_dir).expand_path
+        end
+      end
+      
+      db_files = optparser.parse(argv)
+      case db_files.length
+      when ->(n) {n > 1}
+        "Too many DB_DESCRIPTION_FILEs given"
+      end.tap {|msg| raise ProgramArgumentError.new(msg) if msg}
+      
+      return [db_files[0], options]
+    end
+    
+    def self.generate_from(document, options)
+      db_handler = DatabaseHandler.new(**(options.to_h))
+      engine = Engine.new(document, db_handler)
+      engine.run
+      db_handler.create_source_files
+    end
+    
+    def self.with_db_description_io(file_path, &blk)
+      if file_path
+        File.open(file_path, 'r', &blk)
+      else
+        blk.call($stdin)
+      end
+    end
+    
+    def self.run_program(argv = ARGV.dup)
+      description_file, options = parse_argv(argv)
+      document = with_db_description_io(description_file) do |xml_file|
+        REXML::Document.new(xml_file)
+      end
+      generate_from(document, options)
+    end
+  end
+end
+
+require "mkxms/mssql/database_handler"
+require "mkxms/mssql/engine"
+require "mkxms/mssql/exceptions"
+require "mkxms/mssql/version"
+
+if __FILE__.eql? $0
+  Mkxms::Mssql.run_program
+end

data/mkxms-mssql.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mkxms/mssql/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mkxms-mssql"
+  spec.version       = Mkxms::Mssql::VERSION
+  spec.authors       = ["Richard Weeks"]
+  spec.email         = ["rtweeks21@gmail.com"]
+  spec.summary       = %q{XMigra source files from MS-SQL database description.}
+  spec.description   = %q{Build a complete set of XMigra source files from an XML document (as produced by the mssql-eyewkas.sql script) describing an MS-SQL database.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "xmigra", '~> 1.1'
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/spec/utils/indented_string_builder_spec.rb

@@ -0,0 +1,218 @@
+require 'mkxms/mssql/indented_string_builder'
+
+class RSpec::Expectations::ExpectationTarget
+  def to_have(length_expectation)
+    (match = Object.new).extend RSpec::Matchers
+    to match.have length_expectation
+  end
+  
+  def to_not_have(length_expectation)
+    (match = Object.new).extend RSpec::Matchers
+    to_not match.have length_expectation
+  end
+end
+
+RSpec::Matchers.define :have do |expected|
+  match do |actual|
+    actual.length == expected.count
+  end
+  failure_message do |actual|
+    "expected #{actual} to have #{expected.count} items"
+  end
+end
+
+RSpec::Expectations::LengthExpectation = Struct.new(:count)
+class Integer
+  def items
+    RSpec::Expectations::LengthExpectation.new(self)
+  end
+  
+  def item
+    raise "Numericity mismatch" unless self == 1
+    RSpec::Expectations::LengthExpectation.new(1)
+  end
+end
+
+describe Mkxms::Mssql::IndentedStringBuilder do
+  def check_contractor_example(s)
+    lines = s.to_s.lines
+    expect(lines).to_have 4.items
+    ["SELECT", "  name", "  AND trade", ";"].each.with_index do |line_start, i|
+      expect(lines[i]).to start_with(line_start)
+    end
+  end
+  
+  it "can print a single line like a regular StringIO" do
+    subject.puts("Hello world!")
+    expect(subject.to_s.lines).to_have 1.item
+  end
+  
+  it "can substitute into a line" do
+    sub = "happy"
+    subject.puts("I'm feeling %s.") {sub}
+    expect(subject.to_s).to include(sub)
+    expect(subject.to_s.lines).to_have 1.item
+  end
+  
+  it "can substitue a value that is not a string into a template" do
+    sub = 17
+    subject.puts("I would like %s candy bars.") {sub}
+    expect(subject.to_s).to include(sub.to_s)
+    expect(subject.to_s.lines).to_have 1.item
+  end
+  
+  it "can substitute an indented section" do
+    conditions = "name = 'Joe'\nAND trade='plumber'"
+    subject.puts("SELECT * FROM contractors WHERE %s;", :each_indent=>'  ') {conditions}
+    expect(subject.to_s.lines).to_have 4.items
+    check_contractor_example(subject)
+  end
+  
+  it "can #puts without substitution" do
+    subject.puts("weird %stuff", :sub => nil)
+    expect(subject.to_s).to eql("weird %stuff\n")
+  end
+  
+  context "begin/end template" do
+    let(:template) {"BEGIN".."END"}
+    
+    it "substitutes a single line correctly" do
+      subject.puts(template) {"body"}
+      expect(subject.to_s).to eql("BEGIN\n  body\nEND\n")
+    end
+    
+    it "substitutes multiple lines correctly" do
+      subject.puts(template) {"body1\nbody2"}
+      expect(subject.to_s).to eql("BEGIN\n  body1\n  body2\nEND\n")
+    end
+  end
+  
+  it "yields the matched name if the :sub option is :named" do
+    sub_indicators = []
+    subject.puts("Eeny {meeny} {miney} mo", :sub => :named) {|insert|
+      sub_indicators << insert
+      "woot!"
+    }
+    expect(sub_indicators).to include('meeny')
+    expect(sub_indicators).to include('miney')
+  end
+  
+  context "DSL" do
+    it "reroutes #puts to the builder (not $stdout)" do
+      expect do
+        subject.dsl {
+          puts "Hello, world!"
+        }
+      end.not_to output.to_stdout
+      expect(subject.to_s).to eql("Hello, world!\n")
+    end
+    
+    it "provides for indented blocks" do
+      subject.dsl {
+        puts "SELECT * FROM contractors WHERE"
+        indented {
+          puts "name = 'Joe'"
+          puts "AND trade = 'plumber'"
+        }
+        puts ";"
+      }
+      check_contractor_example(subject)
+    end
+    
+    it "allows indented injection with #puts" do
+      subject.dsl {
+        puts "SELECT * FROM contractors WHERE %s;" do
+          puts "name = 'Joe'"
+          puts "AND trade = 'plumber'"
+        end
+      }
+      check_contractor_example(subject)
+    end
+    
+    it "captures variables from surrounding binding" do
+      the_answer = 42
+      subject.dsl {
+        puts "The answer to the ultimate question of life, the universe, and everything is #{the_answer}."
+      }
+      expect(subject.to_s).to include(the_answer.to_s)
+    end
+    
+    it "allows calls to methods defined in the surrounding binding" do
+      def blargize(s)
+        s + "blarg"
+      end
+      
+      subject.dsl {
+        puts "All answers exist on the #{blargize 'web'}."
+      }
+    end
+    
+    it "does not capture output to $stdout within methods of the surrounding binding" do
+      def real_puts(s)
+        puts s
+      end
+      
+      expect {
+        subject.dsl {
+          real_puts "This goes out!"
+        }
+      }.to output.to_stdout
+    end
+    
+    it "is available from the class and returns a string" do
+      class_dsl_result = subject.class.dsl {
+        puts "Hello, world!"
+      }
+      
+      expect(class_dsl_result).to eql("Hello, world!\n")
+    end
+    
+    context "in subclass" do
+      it "properly handles calls to methods nested within DSL" do
+        test_class = Class.new(subject.class) do
+          def initialize
+            super
+            
+            dsl {
+              puts "BEGIN"
+              indented {
+                add_command
+              }
+              puts "END"
+            }
+          end
+          
+          def add_command
+            dsl {
+              puts "command"
+            }
+          end
+        end
+        
+        test_instance = test_class.new
+        expect(test_instance.to_s).to eql("BEGIN\n  command\nEND\n")
+      end
+      
+      it "property handles plain #puts calls within a called method nested within DSL" do
+        test_class = Class.new(subject.class) do
+          def initialize
+            super
+            
+            dsl {
+              puts "BEGIN"
+              indented {add_command}
+              puts "END"
+            }
+          end
+          
+          def add_command
+            puts "command"
+          end
+        end
+        
+        test_instance = test_class.new
+        expect(test_instance.to_s).to eql("BEGIN\n  command\nEND\n")
+      end
+    end
+  end
+end