mml-ruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 72e0e8b2cf0a3af44cae8cfad91c6881d11aacc8
+  data.tar.gz: 620cda5a27d64f3e487ef21f0fa0a16b29a35cd9
+SHA512:
+  metadata.gz: 873e3037b21b6a874a6c6e513d4938e02f76829443980ce5268a6288646a99b5dada2fe9d4d18b4a9dba54cbf2b55f9f8b5c097fd603dac96d7296f0156d699a
+  data.tar.gz: 00a926a915a2baae33b0339dbb5561aa98eeadbbe2ef970b935f5c99fd249e5be8a18211128c1be5d7e5dbbda2bdc5e42f5bd39ac316319692c35608d52ffc91

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*~
+*#
+\#*
+.\#*
+

data/.rspec

@@ -0,0 +1,2 @@
+--require spec_helper
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2013, Shinji KOBAYASHI
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,36 @@
+[![Build Status](https://travis-ci.org/skoba/mml-ruby.png)](https://travis-ci.org/skoba/mml-ruby)
+
+# Ruby MML(Medical Markup Language) implementation 
+
+This is an preliminary implementation for MML by Ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'mml-ruby'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mml-ruby
+
+## Usage
+
+Make MML from data model and write it to XML form.
+
+## License
+
+This product is provided under Apache 2 license.
+See LICENSE file in detail.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/mml.rb

@@ -0,0 +1,22 @@
+require 'builder'
+
+module MML
+  MML_NAMESPACE = 'xmlns:mml="http://www.medxml.net/MML"'
+
+  class Base
+    def namespace
+      MML_NAMESPACE
+    end
+
+    def to_xml
+      @xb = Builder::XmlMarkup.new
+    end
+  end
+
+  class V2Base < Base
+    VERSION = '2.3'
+  end
+
+  require_relative 'mml/common'
+  require_relative 'mml/version'
+end

data/lib/mml/common.rb

@@ -0,0 +1,306 @@
+require 'builder'
+
+module MML
+  class BaseName
+    attr_reader :value, :repCode
+    attr_accessor :tableId
+
+    def initialize(args ={})
+      %W(value repCode tableId).each do |item|
+        self.send("#{item}=", args[item.to_sym])
+      end      
+    end
+
+    def value=(value)
+      raise ArgumentError, 'value is mandatory' if value.nil?
+      @value = value
+    end
+
+    def repCode=(repCode)
+      raise ArgumentError, 'repCode is mandatory' if repCode.nil?
+      @repCode = repCode
+    end
+  end
+
+  class FacilityName < BaseName
+
+  end
+
+  class DepartmentName < BaseName
+
+  end
+
+  class Name < BaseName
+    attr_accessor :family, :given, :middle, :fullname, :prefix, :degree
+
+    def initialize(args = {})
+      %W(family given middle fullname prefix degree repCode tableId).each do |item|
+        self.send("#{item}=", args[item.to_sym])
+      end
+    end
+
+    undef value=
+
+    def to_xml
+      xb = Builder::XmlMarkup.new
+      xb.mmlNm(:Name, {'mmlNm:repCode' => @repCode, 'mmlNm:tableId' => @tableId}) do
+        xb.mmlNm :family, @family if @family
+        xb.mmlNm :middle, @middle if @middle
+        xb.mmlNm :given, @given if @given
+        xb.mmlNm :fullname, @fullname if @fullname
+        xb.mmlNm :prefix, @prefix if @prefix
+        xb.mmlNm :degree, @degree if @degree
+      end
+    end
+  end
+
+  class Id
+    attr_reader :value, :type, :tableId
+    attr_accessor :checkDigit, :checkDigitSchema
+
+    def initialize(args = {})
+      self.value = args[:value]
+      self.type = args[:type]
+      self.tableId = args[:tableId]
+      self.checkDigit = args[:checkDigit]
+      self.checkDigitSchema = args[:checkDigitSchema]
+    end
+
+    def value=(value)
+      raise ArgumentError, 'value should not be nil' if value.nil? or value.empty?
+      @value = value
+    end
+
+    def type=(type)
+      raise ArgumentError, 'type should no be nil' if type.nil? or type.empty?
+      @type = type
+    end
+
+    def tableId=(tableId)
+      raise ArgumentError, 'table id is required' if tableId.nil? or type.empty?
+      @tableId = tableId
+    end
+
+    def to_xml
+      xb = Builder::XmlMarkup.new
+      attributes = {'mmlCm:type' => type, 'mmlCm:tableId' => tableId }
+      attributes['mmlCm:checkDigit'] = checkDigit if checkDigit
+      attributes['mmlCm:checkDigitSchema'] = checkDigitSchema if checkDigitSchema
+      xb.mmlCm :Id,  value, attributes
+    end
+  end
+
+  class ExtRef
+    attr_accessor :contentType, :medicalRole, :title
+    attr_reader :href
+
+    def initialize(args = {})
+      self.contentType = args[:contentType]
+      self.medicalRole = args[:medicalRole]
+      self.title = args[:title]
+      self.href = args[:href]
+    end
+
+    def href=(href)
+      raise ArgumentError, 'href is mandatory' if href.nil?
+      @href = href
+    end
+
+    def to_xml
+      xb = Builder::XmlMarkup.new
+      attributes = { 'mmlCm:href' => href }
+      attributes['mmlCm:contentType'] = contentType if contentType
+      attributes['mmlCm:medicalRole'] = medicalRole if medicalRole
+      attributes['mmlCm:title'] = title if title
+      xb.mmlCm :extRef, attributes
+    end
+  end
+
+  class Address
+    attr_reader :repCode
+    attr_accessor :addressClass, :tableId, :homeNumber, :town, :city, :prefecture, :full, :zip, :countryCode
+
+    def initialize(args = {})
+      %W(repCode addressClass tableId full homeNumber town city prefecture zip countryCode).each do |item|
+        self.send("#{item}=", args[item.to_sym])
+      end
+    end
+
+    def repCode=(repCode)
+      raise ArgumentError, 'repCode is mandatory' if repCode.nil?
+      @repCode = repCode
+    end
+
+    def to_xml
+      xb = Builder::XmlMarkup.new
+      attributes = { 'mmlAd:repCode' => repCode }
+      attributes['mmlAd:addressClass'] = addressClass
+      attributes['mmlAd:tableId'] = tableId
+      xb.mmlAd :Address, attributes do
+        xb.mmlAd :homeNumber, homeNumber if homeNumber
+        xb.mmlAd :town, town if town
+        xb.mmlAd :city, city if city
+        xb.mmlAd :prefecture, prefecture if prefecture
+        xb.mmlAd :full, full if full
+        xb.mmlAd :zip, zip if zip
+        xb.mmlAd :countryCode, countryCode if countryCode
+      end
+    end
+  end
+
+  class Phone
+    attr_accessor :telEquipType, :area, :city, :number, :extension, :country, :memo
+
+    def initialize(args = {})
+      %W(telEquipType area city number extension country memo).each do |item|
+        self.send("#{item}=", args[item.to_sym])
+      end
+    end
+
+    def to_xml
+      xb = Builder::XmlMarkup.new
+      attributes = {'mmlPh:telEquipType' => telEquipType} if telEquipType
+      xb.mmlPh :Phone, attributes do
+        xb.mmlPh :area, area if area
+        xb.mmlPh :city, city if city
+        xb.mmlPh :number, number if number
+        xb.mmlPh :extension, extension if extension
+        xb.mmlPh :country, country if country
+        xb.mmlPh :memo, memo if memo
+      end
+    end
+  end
+
+  class Facility
+    attr_reader :name
+    attr_accessor :id
+
+    def initialize(args = {})
+      %W(name id).each do |item|
+        self.send("#{item}=", args[item.to_sym])
+      end
+    end
+
+    def name=(name)
+      raise ArgumentError, 'name is mandatory' if name.nil? or name.empty?
+      @name = name
+    end
+
+    def to_xml
+      xb = Builder::XmlMarkup.new
+      xb.mmlFc :Facility do
+        name.each do |n|
+          attributes = {'mmlFc:repCode' => n.repCode}
+          attributes['mmlFc:tableId'] = n.tableId if n.tableId
+          xb.mmlFc :name, n.value, attributes
+        end
+        xb << id.to_xml if id
+      end
+    end
+  end
+
+  class Department < Facility
+    def initialize(args = {})
+      super
+    end
+
+    def to_xml
+      xb = Builder::XmlMarkup.new
+      xb.mmlDp :Department do
+        name.each do |n|
+          attributes = { 'mmlDp:repCode' => n.repCode}
+          attributes['mmlDp:tableId'] = n.tableId if n.tableId
+          xb.mmlDp :name, n.value, attributes
+        end
+        xb << id.to_xml if id
+      end
+    end
+  end
+
+  class PersonalizedInfo
+    attr_reader :id, :personName
+    attr_accessor :facility, :department, :addresses, :emailAddresses, :phones
+
+    def initialize(args = {})
+      %W(id personName facility department addresses emailAddresses phones).each do |item|
+        send "#{item}=", args[item.to_sym]
+      end
+    end
+
+    def id=(id)
+      @id = id
+    end
+
+    def personName=(personName)
+      @personName = personName
+    end
+
+    def to_xml
+      xb = Builder::XmlMarkup.new
+      xb.mmlPsi :PersonalizedInfo do
+        xb << id.to_xml
+        xb.mmlPsi :personName do
+          personName.each do |n|
+            xb << n.to_xml
+          end
+        end
+        xb << facility.to_xml if facility
+        xb << department.to_xml if department
+        xb.mmlPsi :addresses do
+          addresses.each do |address|
+            xb << address.to_xml
+          end
+        end if addresses
+        xb.mmlPsi :emailAddresses do
+          emailAddresses.each do |email|
+            xb.mmlCm :email, email
+          end
+        end if emailAddresses
+        xb.mmlPsi :phones do
+          phones.each do |phone|
+            xb << phone.to_xml
+          end
+        end if phones
+      end
+    end
+  end
+
+  class CreatorLicense
+    attr_accessor :tableId, :value
+
+    def initialize(args = {})
+      @tableId = args[:tableId]
+      @value = args[:value]
+    end
+  end
+
+  class CreatorInfo
+    attr_reader :personalizedInfo, :creatorLicense
+
+    def initialize(args = {})
+      self.personalizedInfo = args[:personalizedInfo]
+      self.creatorLicense = args[:creatorLicense]
+    end
+
+    def personalizedInfo=(personalizedInfo)
+      raise ArgumentError, 'personalizedInfo is mandatory' if personalizedInfo.nil?
+      @personalizedInfo = personalizedInfo
+    end
+
+    def creatorLicense=(creatorLicense)
+      raise ArgumentError, 'creatorLicense is mandatory' if creatorLicense.nil? or creatorLicense.empty?
+      @creatorLicense = creatorLicense
+    end
+
+    def to_xml
+      xb= Builder::XmlMarkup.new
+      xb.mmlCi :CreatorInfo do
+        xb << personalizedInfo.to_xml
+        creatorLicense.each do |license|
+          attributes = {'mmlCi:tableId' => license.tableId} if license.tableId
+          xb.mmlCi :creatorLicense, license.value, attributes
+        end
+      end
+    end
+  end
+end

data/mml-ruby.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mml/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mml-ruby"
+  spec.version       = Mml::Ruby::VERSION
+  spec.authors       = ["Shinji KOBAYASHI"]
+  spec.email         = ["skoba@moss.gr.jp"]
+  spec.description   = %q{Ruby implementation of MML(Medical Markup Language) library}
+  spec.summary       = %q{MML implementation by Ruby}
+  spec.homepage      = ""
+  spec.license       = "Apache2"
+
+  spec.files         = `git ls-files`.split($/)
+  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_dependency "builder"
+  spec.add_dependency 'nokogiri'
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/mml/address_spec.rb

@@ -0,0 +1,67 @@
+describe MML::Address do
+  let(:address) { MML::Address.new(repCode: 'A', addressClass: 'business', tableId: 'MML0025', full: '506, Dept. 9, Kyoto Research Park (KRP), Awata-cho 91, Chudoji, Shimogyo-ku, Kyoto-city', homeNumber: '506, Dept. 9, Kyoto Research Park (KRP)', town: 'Awata-cho 91, Chudoji, Shimogyo-ku', city: 'Kyoto-city', prefecture: 'Kyoto-fu', zip: '600-8815', countryCode: 'JPN') }
+
+  it 'should be an instance of Address' do
+    expect(address).to be_an_instance_of MML::Address
+  end
+
+  it 'repCode should be properly assigned' do
+    expect(address.repCode).to eq 'A'
+  end
+
+  it 'repCode is mandatory' do
+    expect {address.repCode = nil}.to raise_error ArgumentError
+  end
+
+  it 'addressClass should be properly assigned' do
+    expect(address.addressClass).to eq 'business'
+  end
+
+  it 'tableId should be properly assigned' do
+    expect(address.tableId).to eq 'MML0025'
+  end
+
+  it 'homeNumber should be propwerly assigned' do
+    expect(address.homeNumber).to eq '506, Dept. 9, Kyoto Research Park (KRP)'
+  end
+
+  it 'town should be properly assigned' do
+    expect(address.town).to eq 'Awata-cho 91, Chudoji, Shimogyo-ku'
+  end
+
+  it 'city should be properly assigned' do
+    expect(address.city).to eq 'Kyoto-city'
+  end
+
+  it 'prefecture should be properly assigned' do
+    expect(address.prefecture).to eq 'Kyoto-fu'
+  end
+
+  it 'full address should be properly assigned' do
+    expect(address.full).to eq '506, Dept. 9, Kyoto Research Park (KRP), Awata-cho 91, Chudoji, Shimogyo-ku, Kyoto-city'
+  end
+
+  it 'zip should be properly assigned' do
+    expect(address.zip).to eq '600-8815'
+  end
+
+  it 'countryCode should be properly assigned' do
+    expect(address.countryCode).to eq 'JPN'
+  end
+
+  context '#to_xml' do
+    subject { address.to_xml }
+
+    it {should match '<mmlAd:Address mmlAd:'}
+    it {should match 'mmlAd:repCode="A"'}
+    it {should match 'mmlAd:addressClass="business"'}
+    it {should match 'mmlAd:tableId="MML0025"'}
+    it {should match '<mmlAd:full>506, Dept. 9, Kyoto Research Park \(KRP\), Awata-cho 91, Chudoji, Shimogyo-ku, Kyoto-city</mmlAd:full>'}
+    it {should match '<mmlAd:homeNumber>506, Dept. 9, Kyoto Research Park \(KRP\)</mmlAd:homeNumber>'}
+    it {should match '<mmlAd:town>Awata-cho 91, Chudoji, Shimogyo-ku</mmlAd:town>'}
+    it {should match '<mmlAd:city>Kyoto-city</mmlAd:city>'}
+    it {should match '<mmlAd:prefecture>Kyoto-fu</mmlAd:prefecture>'}
+    it {should match '<mmlAd:zip>600-8815</mmlAd:zip>'}
+    it {should match '<mmlAd:countryCode>JPN</mmlAd:countryCode>'}
+  end
+end

data/spec/mml/base_spec.rb

@@ -0,0 +1,11 @@
+describe MML::Base do
+  let(:mml){MML::Base.new}
+
+  it 'should be an instance of MML::Base' do
+    expect(mml).to be_an_instance_of MML::Base
+  end
+
+  it 'namespace should be xmlns:mml="http://www.medxml.net/MML"' do
+    expect(mml.namespace).to eq 'xmlns:mml="http://www.medxml.net/MML"'
+  end
+end

data/spec/mml/creator_info_spec.rb

@@ -0,0 +1,48 @@
+describe MML::CreatorInfo do
+  let(:person_id) { MML::Id.new(type: 'facility', tableId: 'MML00024', value: '54321')}
+  let(:name) {MML::Name.new(repCode: 'A', fullname: 'Shinji KOBAYASHI')}
+  let(:personalizedInfo) {MML::PersonalizedInfo.new(id: person_id, personName: [name])}
+  let(:creator_license) { MML::CreatorLicense.new(tableId: 'MML0026', value: 'doctor')}
+  let(:creator_info){ MML::CreatorInfo.new(personalizedInfo: personalizedInfo, creatorLicense: [creator_license]) }
+
+  it 'personalizedInfo should be assigned properly' do
+    expect(creator_info.personalizedInfo.id.value).to eq '54321'
+  end
+
+  it 'personalizedInfo is mandatory' do
+    expect {creator_info.personalizedInfo = nil}.to raise_error ArgumentError
+  end
+  it 'should be an isntance of CreatorInfo' do
+    expect(creator_info).to be_an_instance_of MML::CreatorInfo
+  end
+
+  it 'default table id is MML0026' do
+    expect(creator_info.creatorLicense[0].tableId).to eq 'MML0026'
+  end
+
+  it 'creator license should be assigned properly' do
+    expect(creator_info.creatorLicense[0].value).to eq 'doctor'
+  end
+
+  context 'creator license is mandatory' do
+    it 'should not be nil' do
+      expect {creator_info.creatorLicense = nil}.to raise_error ArgumentError
+    end
+
+    it 'should not be empty' do
+      expect {creator_info.creatorLicense = []}.to raise_error ArgumentError
+    end
+  end
+  
+  describe '#to_xml' do
+    subject { creator_info.to_xml }
+
+    it {should match '<mmlCi:CreatorInfo>'}
+    it {should match '<mmlPsi:PersonalizedInfo>'}
+    it {should match '>Shinji KOBAYASHI</mmlNm:fullname></mmlNm:Name>'}
+    it {should match '</mmlPsi:PersonalizedInfo>'}
+    it {should match '<mmlCi:creatorLicense mmlCi:tableId="MML0026">'}
+    it {should match '>doctor</mmlCi:creatorLicense>'}
+    it {should match '</mmlCi:CreatorInfo>'}
+  end
+end

data/spec/mml/creator_license_spec.rb

@@ -0,0 +1,16 @@
+describe MML::CreatorLicense do
+  let(:creator_license) { MML::CreatorLicense.new(tableId: 'MML0026',
+                                                  value: 'doctor')}
+
+  it "creator license should be an instance of CreatorLicense" do
+    expect(creator_license).to be_an_instance_of MML::CreatorLicense
+  end
+
+  it 'table id should be MML0026' do
+    expect(creator_license.tableId).to eq 'MML0026'
+  end
+
+  it 'value should be doctor' do
+    expect(creator_license.value).to eq 'doctor'
+  end
+end

data/spec/mml/department_spec.rb

@@ -0,0 +1,48 @@
+describe MML::Department do
+  let(:id) { MML::Id.new(value: '16', type: 'medical', tableId: 'MML0029') }
+  let(:name) { MML::DepartmentName.new(value: 'Cardiovascular Surgery', repCode: 'A', tableId: 'MML0025') }
+  let(:department) { MML::Department.new(id: id, name: [name]) }
+
+  it 'is an instance of MML::Department' do
+    expect(department).to be_an_instance_of MML::Department
+  end
+
+  context 'name' do
+    let(:department_name) { department.name[0] }
+
+    it 'name should assigned properly' do
+      expect(department_name.value).to eq 'Cardiovascular Surgery'
+    end
+
+    it 'name shold not be nil' do
+      expect {department.name = nil}.to raise_error ArgumentError
+    end
+
+    it 'name should not be empty' do
+      expect {department.name = []}.to raise_error ArgumentError
+    end
+  end
+
+  it 'id should be properyl assigned' do
+    expect(department.id.value).to eq '16'
+  end
+
+  it 'id is not mandatory' do
+    expect { department.id = nil}.not_to raise_error
+  end
+
+  context "#to_xml" do
+    subject { department.to_xml }
+
+    it {should match '<mmlDp:Department>'}
+    it {should match '<mmlDp:name'}
+    it {should match 'mmlDp:repCode="A"'}
+    it {should match 'mmlDp:tableId="MML0025"'}
+    it {should match '>Cardiovascular Surgery</mmlDp:name>'}
+    it {should match '<mmlCm:Id'}
+    it {should match 'mmlCm:type="medical"'}
+    it {should match 'mmlCm:tableId="MML0029"'}
+    it {should match '>16</mmlCm:Id>'}
+    it {should match '</mmlDp:Department>'}
+  end
+end

data/spec/mml/external_ref_spec.rb

@@ -0,0 +1,37 @@
+describe MML::ExtRef do
+  let(:ext_ref) { MML::ExtRef.new(contentType: 'APPLICATION/HL72.3-HL7ER2.3', medicalRole: 'prescription', title: 'Prescription on discharge', href: 'patient1234/prescription831.HL7' )}
+
+  it 'should be an instance of MML::ExtRef' do
+    expect(ext_ref).to be_an_instance_of MML::ExtRef
+  end
+
+  it 'content type should be APPLICATION/HL72.3-HL7ER2.3' do
+    expect(ext_ref.contentType).to eq 'APPLICATION/HL72.3-HL7ER2.3'
+  end
+
+  it 'medical role should be prescription' do
+    expect(ext_ref.medicalRole).to eq 'prescription'
+  end
+
+  it 'title should be Prescription on discharge' do
+    expect(ext_ref.title).to eq 'Prescription on discharge'
+  end
+
+  it 'href should be patient1234/prescription831.HL7' do
+    expect(ext_ref.href).to eq 'patient1234/prescription831.HL7'
+  end
+
+  it 'href is mandatory' do
+    expect {ext_ref.href=nil}.to raise_error ArgumentError
+  end
+
+  context '#to_xml' do
+    subject { ext_ref.to_xml }
+
+    it { should match '<mmlCm:extRef'}
+    it { should match 'mmlCm:contentType="APPLICATION/HL72.3-HL7ER2.3"'}
+    it { should match 'mmlCm:medicalRole="prescription"'}
+    it { should match 'mmlCm:title="Prescription on discharge"'}
+    it { should match 'mmlCm:href="patient1234/prescription831.HL7"'}
+  end
+end

data/spec/mml/facility_name_spec.rb

@@ -0,0 +1,18 @@
+describe MML::FacilityName do
+  let(:facility_name) { MML::FacilityName.new(value: 'New Millenium Medical College Hospital', repCode: 'A', tableId: 'MML0025') }
+
+  it 'should be an instance of MML::FacilityName' do
+    expect(facility_name).to be_an_instance_of MML::FacilityName
+  end
+
+  it 'value should be assigned porperly' do
+    expect(facility_name.value).to eq 'New Millenium Medical College Hospital'
+  end
+  it 'repCode should be assigned properly' do
+    expect(facility_name.repCode).to eq 'A'
+  end
+
+  it 'tableId should be assigned properly' do
+    expect(facility_name.tableId).to eq 'MML0025'
+  end
+end

data/spec/mml/facility_spec.rb

@@ -0,0 +1,50 @@
+describe MML::Facility do
+  let(:id) { MML::Id.new(value: '12345', type: 'facility', tableId: 'MML0024', checkDigit: 5, checkDigitSchema: 'MML0001') }
+  let(:name) { MML::FacilityName.new(value: 'New Millenium Medical College Hospital', repCode: 'A', tableId: 'MML0025') }
+  let(:facility) { MML::Facility.new(name: [name], id: id) }
+
+  it 'should be an instance of MML::Facility' do
+    expect(facility).to be_an_instance_of MML::Facility
+  end
+
+  context 'name' do
+    let(:facility_name) { facility.name[0] }
+
+    it 'name should be assigned properly' do
+      expect(facility_name.value).to eq 'New Millenium Medical College Hospital'
+    end
+
+    it 'repCode should be assigned properly' do
+      expect(facility_name.repCode).to eq 'A'
+    end
+
+    it 'talbeId should be assigned properly' do
+      expect(facility_name.tableId).to eq 'MML0025'
+    end
+
+    it 'facility name is mandatory' do
+      expect{ facility.name = nil }.to raise_error ArgumentError
+    end
+  end
+
+  it 'id should be properly assgined' do
+    expect(facility.id.value).to eq '12345'
+  end
+
+  it 'id is not mandatory' do
+    expect {facility.id = nil}.not_to raise_error
+  end
+
+  context '#to_xml' do
+    subject { facility.to_xml}
+
+    it {should match '<mmlFc:Facility>'}
+    it {should match '<mmlFc:name mmlFc:'}
+    it {should match 'mmlFc:repCode="A"'}
+    it {should match 'mmlFc:tableId="MML0025"'}
+    it {should match '<mmlCm:Id mmlCm:type="facility"'}
+    it {should match 'mmlCm:tableId="MML0024"'}
+    it {should match 'mmlCm:checkDigit="5"'}
+    it {should match 'mmlCm:checkDigitSchema="MML0001"'}
+  end
+end

data/spec/mml/identification_spec.rb

@@ -0,0 +1,61 @@
+describe MML::Id do
+  let(:id) { MML::Id.new(value: '12345', type: 'facility', tableId: 'MML0024', checkDigit: 5, checkDigitSchema: 'MML0001') }
+
+  it 'should be an instance of MML::Id' do
+    expect(id).to be_an_instance_of MML::Id
+  end
+
+  it 'value should be 12345' do
+    expect(id.value).to eq '12345'
+  end
+
+  it 'value is mandatory' do
+    expect { id.value = nil }.to raise_error ArgumentError
+  end
+
+  it 'type should be facility' do
+    expect(id.type).to eq 'facility'
+  end
+
+  it 'type is mandatory' do
+    expect { id.type = nil }.to raise_error ArgumentError
+  end
+
+  it 'tableId should be MML0024' do
+    expect(id.tableId).to eq 'MML0024'
+  end
+
+  it 'tableId is required' do
+    expect{id.tableId = nil}.to raise_error ArgumentError
+  end
+
+  it 'check digit is 5' do
+    expect(id.checkDigit).to be 5
+  end
+
+  it 'check digit schema is MML0001' do
+    expect(id.checkDigitSchema).to eq 'MML0001'
+  end
+
+  context '#to_xml' do
+    it 'assigned type attribute matches facility' do
+      expect(id.to_xml).to match 'mmlCm:type="facility"'
+    end
+
+    it 'assigned tableId matches MML0024' do
+      expect(id.to_xml).to match 'mmlCm:tableId="MML0024"'
+    end
+
+    it 'assigned check digit matches 5' do
+      expect(id.to_xml).to match 'mmlCm:checkDigit="5"'
+    end
+
+    it 'assigned check digit schema matches MML0001' do
+      expect(id.to_xml).to match 'mmlCm:checkDigitSchema="MML0001"'
+    end
+
+    it 'assigned value match 12345' do
+      expect(id.to_xml).to match '>12345</mmlCm:Id>'
+    end
+  end
+end

data/spec/mml/name_spec.rb

@@ -0,0 +1,67 @@
+describe MML::Name do
+  let(:name) {MML::Name.new(repCode: 'A', tableId: 'MML0025', family: 'KOBAYASHI', given: 'Shinji', middle: 'middle', fullname: 'KOBAYASHI, Shinji', prefix: 'Dr', degree: 'MD, PhD')}
+
+  it 'name should be an instance of MML::Name' do
+    expect(name).to be_an_instance_of MML::Name
+  end
+
+  it 'repCode should be A' do
+    expect(name.repCode).to eq 'A'
+  end
+
+  it 'tableId should be MML0025' do
+    expect(name.tableId).to eq 'MML0025'
+  end
+
+  it 'repCode is mandatory' do
+    expect{name.repCode = nil}.to raise_error
+  end
+
+  it 'family name is KOBAYASHI' do
+    expect(name.family).to eq 'KOBAYASHI'
+  end
+
+  it 'given name is Shinji' do
+    expect(name.given).to eq 'Shinji'
+  end
+
+  it 'middle name is middle' do
+    expect(name.middle).to eq 'middle'
+  end
+
+  it 'full name is KOBAYASHI, Shinji' do
+    expect(name.fullname).to eq 'KOBAYASHI, Shinji'
+  end
+
+  it 'prefix should be Dr' do
+    expect(name.prefix).to eq 'Dr'
+  end
+
+  it 'degree is MD, PhD' do
+    expect(name.degree).to eq 'MD, PhD'
+  end
+
+  context '#to_xml' do
+    let(:xml) { name.to_xml }
+    
+    it 'mmlNm:given tag matches Shinji' do
+      expect(xml).to match '<mmlNm:given>Shinji</mmlNm:given>'
+    end
+
+    it 'mmlNm:family tag matches KOBAYASHI' do
+      expect(xml).to match '<mmlNm:family>KOBAYASHI</mmlNm:family>'
+    end
+
+    it 'mmlNm:fullname tag matches KOBAYASHI, Shinji' do
+      expect(xml).to match '<mmlNm:fullname>KOBAYASHI, Shinji</mmlNm:fullname>'
+    end
+
+    it 'mmlNm:prefix tag matches Dr' do
+      expect(xml).to match '<mmlNm:prefix>Dr</mmlNm:prefix>'
+    end
+
+    it 'mmlNm:degree tag matches MD, PhD' do
+      expect(xml).to match '<mmlNm:degree>MD, PhD</mmlNm:degree>'
+    end
+  end
+end

data/spec/mml/personalized_info_spec.rb

@@ -0,0 +1,79 @@
+describe MML::PersonalizedInfo do
+  let(:id) { MML::Id.new(type: 'facility', tableId: 'MML0024', value: '5555') }
+  let(:personName) { MML::Name.new(repCode: 'A', fullname: 'Shinji KOBAYASHI') }
+  let(:facility_id) { MML::Id.new(type: 'insurance', tableId: 'MML0027', value: '12345')}
+  let(:facility_name) {MML::FacilityName.new(value: 'New Millenium Medical College Hospital', repCode: 'A', tableId: 'MML0025')}
+  let(:facility) { MML::Facility.new(id: facility_id, name: [facility_name]) }
+  let(:department_name){MML::DepartmentName.new(repCode: 'A', tableId: 'MML0025', value: 'Cardiovascular surgery')}
+  let(:department) { MML::Department.new(name: [department_name])}
+  let(:address) { MML::Address.new(repCode: 'A', tableId: 'MML0025', addressClass: 'business', full: '5200 Kihara, Kiyotake-cho, Miyazaki-gun, Miyazaki-prefecture', zip: '889-1692', countryCode: 'JPN') }
+  let(:email) {'araki@post.medxml.net'}
+  let(:phone) {MML::Phone.new(telEquipType: 'PH', area: '0985', city: '85', number: '1500')}
+  let(:personalized_info) { MML::PersonalizedInfo.new(id: id, personName: [personName], facility: facility, department: department, addresses: [address], emailAddresses: [email], phones: [phone]) }
+
+  it 'personalized info should be an instance of PersonalizedInfo' do
+    expect(personalized_info).to be_an_instance_of MML::PersonalizedInfo
+  end
+
+  it 'id should be assigned properly' do
+    expect(personalized_info.id.value).to eq '5555'
+  end
+
+  it 'personName should be assigned properly' do
+    expect(personalized_info.personName[0].fullname).to eq 'Shinji KOBAYASHI'
+  end
+
+  it 'faciilty should be assigned properly' do
+    expect(personalized_info.facility.name[0].value).to eq 'New Millenium Medical College Hospital'
+  end
+
+  it 'department should be assigned properly' do
+    expect(personalized_info.department.name[0].value).to eq 'Cardiovascular surgery'
+  end
+
+  it 'addresses are properly assined' do
+    expect(personalized_info.addresses[0].zip).to eq '889-1692'
+  end
+
+  it 'emailAddresses are properly assigned' do
+    expect(personalized_info.emailAddresses[0]).to eq 'araki@post.medxml.net'
+  end
+
+  it 'phones are properly assigned' do
+    expect(personalized_info.phones[0].area).to eq '0985'
+  end
+
+  describe "#to_xml" do
+    subject { personalized_info.to_xml }
+
+    it {should match '<mmlPsi:PersonalizedInfo>'}
+    it {should match '<mmlCm:Id'}
+    it {should match 'mmlCm:type="facility"'}
+    it {should match '<mmlPsi:personName>'}
+    it {should match '<mmlNm:Name'}
+    it {should match '<mmlNm:fullname>Shinji KOBAYASHI</mmlNm:fullname>'}
+    it {should match '</mmlNm:Name>'}
+    it {should match '<mmlFc:Facility>'}
+    it {should match '<mmlFc:name'}
+    it {should match '>New Millenium Medical College Hospital</mmlFc:name>'}
+    it {should match 'mmlCm:tableId="MML0027"'}
+    it {should match '>12345</mmlCm:Id>'}
+    it {should match '</mmlFc:Facility>'}
+    it {should match '<mmlDp:Department>'}
+    it {should match '>Cardiovascular surgery</mmlDp:name>'}
+    it {should match '</mmlDp:Department>'}
+    it {should match '<mmlPsi:addresses>'}
+    it {should match '<mmlAd:full>5200 Kihara, Kiyotake-cho, Miyazaki-gun, Miyazaki-prefecture'}
+    it {should match '</mmlAd:full>'}
+    it {should match '</mmlPsi:addresses>'}
+    it {should match '<mmlPsi:emailAddresses>'}
+    it {should match '<mmlCm:email>araki@post.medxml.net</mmlCm:email>'}
+    it {should match '</mmlPsi:emailAddresses>'}
+    it {should match '<mmlPsi:phones>'}
+    it {should match '<mmlPh:Phone'}
+    it {should match 'mmlPh:telEquipType="PH">'}
+    it {should match '<mmlPh:city>85</mmlPh:city>'}
+    it {should match '</mmlPsi:phones>'}
+    it {should match '</mmlPsi:PersonalizedInfo>'}
+  end
+end

data/spec/mml/phone_spec.rb

@@ -0,0 +1,48 @@
+describe MML::Phone do
+  let(:phone) { MML::Phone.new(telEquipType: 'PH', area: '075', city: '874', number: '7030', extension: '123', country: '81', memo: 'daytime') }
+
+  it 'should be an instance of MML::Phone' do
+    expect(phone).to be_an_instance_of MML::Phone
+  end
+
+  it 'equipType should be properly assigned' do
+    expect(phone.telEquipType).to eq 'PH'
+  end
+
+  it 'area number should be assigned properly' do
+    expect(phone.area).to eq '075'
+  end
+
+  it 'city number should be assigned properly' do
+    expect(phone.city).to eq '874'
+  end
+
+  it 'number should be assigned properly' do
+    expect(phone.number).to eq'7030'
+  end
+
+  it 'extension should be assigned properly' do
+    expect(phone.extension).to eq '123'
+  end
+
+  it 'country code should be assigned properly' do
+    expect(phone.country).to eq '81'
+  end
+
+  it 'memo should be assigned properly' do
+    expect(phone.memo).to eq 'daytime'
+  end
+
+  context '#xml' do
+    subject { phone.to_xml }
+
+    it {should match '<mmlPh:Phone mmlPh:telEquipType="PH">'}
+    it {should match '<mmlPh:area>075</mmlPh:area>'}
+    it {should match '<mmlPh:city>874</mmlPh:city>'}
+    it {should match '<mmlPh:number>7030</mmlPh:number>'}
+    it {should match '<mmlPh:extension>123</mmlPh:extension>'}
+    it {should match '<mmlPh:country>81</mmlPh:country>'}
+    it {should match '<mmlPh:memo>daytime</mmlPh:memo>'}
+    it {should match '</mmlPh:Phone>'}
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require "rubygems"
+require "bundler/setup"
+require 'rspec'
+Dir[File.join(File.dirname(__FILE__), "..", "lib", "**/*.rb")].each{|f| require f }
+
+RSpec.configure do
+
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: mml-ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Shinji KOBAYASHI
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby implementation of MML(Medical Markup Language) library
+email:
+- skoba@moss.gr.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/mml.rb
+- lib/mml/common.rb
+- mml-ruby.gemspec
+- spec/mml/address_spec.rb
+- spec/mml/base_spec.rb
+- spec/mml/creator_info_spec.rb
+- spec/mml/creator_license_spec.rb
+- spec/mml/department_spec.rb
+- spec/mml/external_ref_spec.rb
+- spec/mml/facility_name_spec.rb
+- spec/mml/facility_spec.rb
+- spec/mml/identification_spec.rb
+- spec/mml/name_spec.rb
+- spec/mml/personalized_info_spec.rb
+- spec/mml/phone_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- Apache2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: MML implementation by Ruby
+test_files:
+- spec/mml/address_spec.rb
+- spec/mml/base_spec.rb
+- spec/mml/creator_info_spec.rb
+- spec/mml/creator_license_spec.rb
+- spec/mml/department_spec.rb
+- spec/mml/external_ref_spec.rb
+- spec/mml/facility_name_spec.rb
+- spec/mml/facility_spec.rb
+- spec/mml/identification_spec.rb
+- spec/mml/name_spec.rb
+- spec/mml/personalized_info_spec.rb
+- spec/mml/phone_spec.rb
+- spec/spec_helper.rb