building_sync_rails 0.1.0

data/lib/building_sync_rails/engine.rb

@@ -0,0 +1,15 @@
+module BuildingSyncRails
+  class Engine < ::Rails::Engine
+    config.to_prepare do
+      require_relative "../../config/initializers/BuildingSync_initializer.rb"
+      require_relative "../../config/initializers/soap4r_ns_fix.rb"
+      require_relative "../../config/initializers/soap4r_xsd_datatypes_fix.rb"
+
+      require_relative "../../lib/building_sync_tk.rb"
+    end
+
+    # initializer "static" do |app|
+    #   app.middleware.insert_before(::ActionDispatch::Static, ::ActionDispatch::Static, ::File.join(root, "public"))
+    # end
+  end
+end

data/lib/building_sync_rails/version.rb

@@ -0,0 +1,3 @@
+module BuildingSyncRails
+  VERSION = "0.1.0"
+end

data/lib/building_sync_rails.rb

@@ -0,0 +1,5 @@
+require "building_sync_rails/engine"
+require "building_sync_rails/version"
+
+module BuildingSyncRails
+end

data/lib/building_sync_tk/factory.rb

@@ -0,0 +1,186 @@
+require "isomorphic/factory"
+
+module BuildingSyncTk
+  # An Isomorphic factory that is specialized for the {BuildingSync} base module.
+  class Factory < ::Isomorphic::Factory::AbstractFactory
+    # @!scope class
+
+    # @!method instance
+    #   @return [BuildingSyncTk::Factory] the singleton instance
+    include ::Singleton
+
+    # @!scope instance
+
+    # Private constructor.
+    def initialize
+      super(::BuildingSync)
+    end
+
+    # Get +<auc:UserDefinedFields>+ for the given object.
+    #
+    # @param object [#userDefinedFields] the object
+    # @return [Hash<String, Array<String>>, nil] the key-value pairs as a hash or +nil+ if the given object is invalid
+    #
+    # @note The return value is a hash of arrays (not a hash) because +<auc:FieldName>+ elements are not guaranteed unique within the +<auc:UserDefinedFields>+ element.
+    def get_user_defined_fields(object)
+      object.try(:userDefinedFields).try { |building_sync_user_defined_fields|
+        if building_sync_user_defined_fields.is_a?(::BuildingSync::UserDefinedFields)
+          building_sync_user_defined_fields.inject({}) { |acc, building_sync_user_defined_fields_user_defined_field|
+            if building_sync_user_defined_fields_user_defined_field.is_a?(::BuildingSync::UserDefinedFields::UserDefinedField)
+              building_sync_user_defined_fields_user_defined_field.send(:fieldName).try(:to_s).try { |key|
+                building_sync_user_defined_fields_user_defined_field.send(:fieldValue).try(:to_s).try { |value|
+                  acc[key] ||= []
+                  acc[key] << value
+                }
+              }
+            end
+
+            acc
+          }
+        else
+          nil
+        end
+      }
+    end
+
+    # Build an instance of the given class that represents a "link" to the given target.
+    #
+    # In BuildingSync XML, a "link" is an element with an +@IDref+ attribute.  The value of the +@IDref+ attribute is the value of the +@ID+ attribute of another element.
+    #
+    # @param instance_class [Class] the class for the "link"
+    # @param target_instance [#xmlattr_ID] the target instance
+    # @param options [Hash<#to_sym, Object>] the options
+    # @option options [Hash<#to_sym, Object>] :attributes ({}) the attributes for the "link"
+    # @option options [Hash<#to_sym, #to_s>] :xmlattrs ({}) the XML attributes for the "link"
+    # @yieldparam instance [Object] the "link"
+    # @yieldreturn [void]
+    # @return [Object] the "link"
+    # @raise [Isomorphic::InvalidFactoryClass] if the given class is invalid
+    def link(instance_class, target_instance, **options, &block)
+      send(:for, instance_class, **options.merge({
+        attributes: (options[:attributes] || {}).merge({
+          xmlattr_IDref: target_instance.send(:xmlattr_ID),
+        }),
+      }), &block)
+    end
+
+    # Build an instance of the given class that represents a "link" from the given source to the given target, and then assign the "link" to the source using the given method name.
+    #
+    # @param instance_method_name [#to_s] the method name
+    # @param instance_class [Class] the class for the "link"
+    # @param source_instance [#xmlattr_ID] the source instance
+    # @param target_instance [#xmlattr_ID] the target instance
+    # @param options [Hash<#to_sym, Object>] the options
+    # @option options [Hash<#to_sym, Object>] :attributes ({}) the attributes for the "link"
+    # @option options [Hash<#to_sym, #to_s>] :xmlattrs ({}) the XML attributes for the "link"
+    # @yieldparam instance [Object] the "link"
+    # @yieldreturn [void]
+    # @return [Object] the "link"
+    # @raise [Isomorphic::InvalidFactoryClass] if the given class is invalid
+    def link_to(instance_method_name, instance_class, source_instance, target_instance, **options, &block)
+      source_instance.send(:"#{instance_method_name}=", send(:link, instance_class, target_instance, **options, &block))
+    end
+
+    # Build an instance of the given class that represents a "link" from the given source to the given target, and then append the "link" to the "collection of links" for the source using the given method name.
+    #
+    # @param collection_method_name [#to_s] the method name
+    # @param collection_class [Class] the class for the "link"
+    # @param instance_class [Class] the class for the "link"
+    # @param source_instance [#xmlattr_ID] the source instance
+    # @param target_instance [#xmlattr_ID] the target instance
+    # @param options [Hash<#to_sym, Object>] the options
+    # @option options [Hash<#to_sym, Object>] :attributes ({}) the attributes for the "link"
+    # @option options [Hash<#to_sym, #to_s>] :xmlattrs ({}) the XML attributes for the "link"
+    # @yieldparam instance [Object] the "link"
+    # @yieldreturn [void]
+    # @return [Object] the "link"
+    # @raise [Isomorphic::InvalidFactoryClass] if the given class is invalid
+    def link_to_collection(collection_method_name, collection_class, instance_class, source_instance, target_instance, **options, &block)
+      collection = source_instance.send(collection_method_name) || source_instance.send(:"#{collection_method_name}=", send(:for, collection_class))
+
+      unless (instance = collection.select { |instance| instance.send(:xmlattr_IDref) == target_instance.send(:xmlattr_ID) }.first).nil?
+        instance
+      else
+        instance = send(:link, instance_class, target_instance, **options, &block)
+
+        collection << instance
+
+        instance
+      end
+    end
+
+    # Set +<auc:UserDefinedFields>+ for the given object.
+    #
+    # @param object [#userDefinedFields] the object
+    # @param hash [Hash<String, String>, nil] the key-value pairs
+    # @return [BuildingSync::UserDefinedFields] the +<auc:UserDefinedFields>+ instance
+    def set_user_defined_fields(object, hash = {})
+      hash.each do |key, value|
+        unless user_defined_field?(object, key, value)
+          send(:path, object, :userDefinedFields) << send(:for, ::BuildingSync::UserDefinedFields::UserDefinedField, attributes: {
+            fieldName: key.to_s,
+            fieldValue: value.to_s
+          })
+        end
+      end
+
+      object.send(:userDefinedFields)
+    end
+
+    # Is a +<auc:UserDefinedField>+ present with the given key-value pair?
+    #
+    # @param object [#userDefinedFields] the object
+    # @param key [#to_s] the key
+    # @param value [#to_s] the value
+    # @return [Boolean] +true+ if the given key-value pair is present; otherwise, +false+
+    def user_defined_field?(object, key, value)
+      return false if key.nil? || value.nil?
+
+      send(:path, object, :userDefinedFields, try: true).try(:any?) { |building_sync_user_defined_fields_user_defined_field|
+        building_sync_user_defined_fields_user_defined_field.is_a?(::BuildingSync::UserDefinedFields::UserDefinedField) && building_sync_user_defined_fields_user_defined_field.send(:fieldName).try(:to_s).try(:==, key.to_s) && building_sync_user_defined_fields_user_defined_field.send(:fieldValue).try(:to_s).try(:==, value.to_s)
+      }
+    end
+
+    # The XML attribute names.
+    #
+    # @return [Array<#to_sym>] the XML attribute names
+    #
+    # @note In BuildingSync XML, elements may have an +@ID+ attribute.
+    # @see #xmlattr_ID_for
+    def xmlattrs
+      %w(ID)
+    end
+
+    protected
+
+    # Checks for a constant with the given name in the base module.
+    #
+    # @param base [Module] the base module
+    # @param klass [Class] the class
+    # @param const_name [#to_sym] the constant name
+    # @return [Class, Module, nil] the constant with the given name or +nil+ if not defined
+    #
+    # @note In BuildingSync XML, the constant may be of the given class, of the base module, or of the base module with the "Type" suffix.
+    def const_get(base, klass, const_name)
+      if klass.const_defined?(const_name)
+        klass.const_get(const_name)
+      elsif base.const_defined?(const_name)
+        base.const_get(const_name)
+      elsif base.const_defined?(:"#{const_name}Type")
+        base.const_get(:"#{const_name}Type")
+      else
+        nil
+      end
+    end
+
+    # Builds the value of the +@ID+ attribute for the given object.
+    #
+    # @param object [Object] the object
+    # @return [String] the value of the +@ID+ attribute
+    #
+    # @note Using the {Object#object_id} ensures that the return value is unique.
+    def xmlattr_ID_for(object)
+      "#{object.class.name.split("::")[-1]}-#{object.object_id}"
+    end
+  end
+end

data/lib/building_sync_tk/inflector.rb

@@ -0,0 +1,27 @@
+require "isomorphic/inflector"
+
+module BuildingSyncTk
+  # An Isomorphic inflector that is specialized for the {BuildingSync} base module.
+  class Inflector < ::Isomorphic::Inflector::AbstractInflector
+    # @!scope class
+
+    # @!method instance
+    #   @return [BuildingSyncTk::Inflector] the singleton instance
+    include ::Singleton
+
+    # @!scope instance
+
+    # Private constructor.
+    def initialize
+      super(::BuildingSync)
+    end
+
+    # @!method building_sync
+    #   Inflect upon the given terms.  Alias for {#isomorphism}.
+    #
+    #   @param terms [Array<Object>] the inflectable terms
+    #   @return [String] the inflection
+    #   @raise [Isomorphic::InflectorError] if an inflectable term is invalid
+    alias_method :building_sync, :isomorphism
+  end
+end

data/lib/building_sync_tk/memoization.rb

@@ -0,0 +1,50 @@
+require "building_sync_tk/inflector"
+
+require "isomorphic/memoization"
+
+module BuildingSyncTk
+  # @see Isomorphic::Memoization
+  module Memoization
+    extend ::ActiveSupport::Concern
+
+    included do
+      include ::Isomorphic::Memoization
+    end
+
+    class_methods do
+      # @!scope class
+
+      # Defines finder methods and instance variables for the Active Record associations given by name.
+      #
+      # @param terms [Array<Object>] the inflectable terms
+      # @param association_names [Array<#to_s>] the association names
+      # @param options [Hash<Symbol, Object>] the options
+      # @option options [Array<#to_s>] :xmlattrs ([]) the XML attribute names
+      # @return [void]
+      # @raise [Isomorphic::InflectorError] if an inflectable term is invalid
+      def memo_building_sync_for(*args)
+        memo_isomorphism_for(BuildingSyncTk::Inflector.instance, *args, xmlattrs: BuildingSyncTk::Factory.instance.xmlattrs)
+      end
+
+      # Returns the memo-cahe.
+      #
+      # @return [Hash<Module, ActiveSupport::HashWithIndifferentAccess>] the memo-cache
+      def memo_building_sync_method_names_by_association_name
+        memo_isomorphism_method_names_by_association_name_for(BuildingSyncTk::Inflector.instance.base)
+      end
+    end
+
+    # @!scope instance
+
+    # Find all memoized instances for the given Active Record record by XML attribute name.
+    #
+    # @param record [ActiveRecord::Base] the Active Record record
+    # @param options [Hash<Symbol, Object>] the options
+    # @option options [Array<#to_s>] :xmlattrs ([]) the XML attribute names
+    # @return [ActiveSupport::HashWithIndifferentAccess] the memoized instances by XML attribute name
+    # @raise [Isomorphic::InflectorError] if an inflectable term is invalid
+    def find_all_with_memo_building_sync_for(*args)
+      find_all_with_memo_isomorphism_for(BuildingSyncTk::Inflector.instance, *args, xmlattrs: BuildingSyncTk::Factory.instance.xmlattrs)
+    end
+  end
+end

data/lib/building_sync_tk/model.rb

@@ -0,0 +1,37 @@
+require "active_support/concern"
+
+require "building_sync_tk/factory"
+require "building_sync_tk/inflector"
+
+require "isomorphic/model"
+
+module BuildingSyncTk
+  # @see Isomorphic::Model
+  module Model
+    extend ::ActiveSupport::Concern
+
+    included do
+      include ::Isomorphic::Model
+    end
+
+    class_methods do
+      # @!scope class
+
+      # Define an isomorphism for the given class and optional alias name.
+      #
+      # @param isomorphism_class [Class] the class for the isomorphism
+      # @param method_suffix [#to_s] the optional alias name for the isomorphism
+      # @param options [Hash<Symbol, Object>] the options
+      # @option options [Boolean] :allow_blank (false) +true+ if the root node should always return a non-+nil+ target
+      # @option options [Hash<Symbol, Object>] :attributes ({}) default attributes for the target
+      # @option options [Boolean] :collection (false) +true+ if the target is a collection
+      # @yieldparam node [Isomorphic::Node::Root] the root node
+      # @yieldreturn [void]
+      # @return [void]
+      # @raise [Isomorphic::InflectorError] if an inflectable term is invalid
+      def building_sync_for(*args, &block)
+        isomorphism_for(BuildingSyncTk::Factory.instance, BuildingSyncTk::Inflector.instance, *args, &block)
+      end
+    end
+  end
+end

data/lib/building_sync_tk/version.rb

@@ -0,0 +1,3 @@
+module BuildingSyncTk
+  VERSION = "0.0.1"
+end

data/lib/building_sync_tk.rb

@@ -0,0 +1,12 @@
+require "active_support/dependencies/autoload"
+
+require "building_sync_tk/version"
+
+module BuildingSyncTk
+  extend ::ActiveSupport::Autoload
+
+  autoload :Factory,     "building_sync_tk/factory"
+  autoload :Inflector,   "building_sync_tk/inflector"
+  autoload :Memoization, "building_sync_tk/memoization"
+  autoload :Model,       "building_sync_tk/model"
+end

data/lib/tasks/building_sync_rails_tasks.rake

@@ -0,0 +1,157 @@
+require "fileutils"
+require "open-uri"
+require "set"
+
+# @return [String] the format string for an XML Schema Definition (XSD) import element
+FORMAT_XSD_IMPORT_ = '<%s:import namespace="%s" schemaLocation="%s"/>'.freeze
+
+# @return [Regexp] the regular expression for an XML Schema Definition (XSD) import element
+REGEXP_XSD_IMPORT_ = ::Regexp.new([
+  ::Regexp.escape('<'),
+  '([^:]+)',
+  ::Regexp.escape(':import'),
+  '\s+',
+  ::Regexp.escape('namespace="'),
+  '([^"]+)',
+  ::Regexp.escape('"'),
+  '\s+',
+  ::Regexp.escape('schemaLocation="'),
+  '([^"]+)',
+  ::Regexp.escape('"'),
+  '\s*',
+  ::Regexp.escape('/>'),
+].join).freeze
+
+# Download an XML Schema Definition (XSD) file and recursively download its dependencies.
+#
+# @param url [String] the URL of the XML Schema Definition (XSD) file to download
+# @param verbose [Boolean] specifies the verbosity level
+# @param cached_urls [Set<String>] the cache of URLs that have been downloaded
+# @return [void]
+def download_schema_recursive(url, verbose = true, cached_urls = ::Set.new)
+  if cached_urls.include?(url)
+    return
+  else
+    cached_urls << url
+  end
+
+  $stderr.puts(::Kernel.sprintf("** Download %s", url)) if verbose
+
+  s = ::URI.parse(url).open do |io|
+    io.read.gsub(REGEXP_XSD_IMPORT_) { |match_s|
+      prefix = ::Regexp.last_match[1]
+      namespace = ::Regexp.last_match[2]
+      schema_location = ::Regexp.last_match[3]
+
+      download_schema_recursive(schema_location, verbose, cached_urls)
+
+      # @note Replace the URL with the path on the local disk.
+      ::Kernel.sprintf(FORMAT_XSD_IMPORT_, prefix, namespace, schema_location.split(::File::SEPARATOR)[-1])
+    }
+  end
+
+  # @note Open the new file in binary mode to avoid character encoding issues.
+  ::File.open(::File.join("public", url.split(::File::SEPARATOR)[-1]), "wb") do |io|
+    io.puts(s)
+  end
+
+  return
+end
+
+namespace :building_sync_rails do
+  desc "Use BuildingSync XSD file to generate Ruby code via `xsd2ruby.rb` script."
+  task :xsd2ruby => :environment do
+    # @!attribute [r] uri_xsd_remote
+    #   @return [String] the location of the BuildingSync XSD file on the remote nework
+    uri_xsd_remote = "https://github.com/BuildingSync/schema/raw/develop-v2/BuildingSync.xsd"
+
+    # @!attribute [r] options_by_local_name
+    #   @return [Hash<String, Hash<Symbol, Array<Hash<Symbol, Object>>>>] the options by the local name of each Ruby source file
+    #   @note Ruby source files are auto-generated by the "soap4r" gem.  This data structure contains the information that is used to sanitize the auto-generated code, making it suitable for revision management.
+    options_by_local_name = {
+      "BuildingSync.rb" => {
+        delete_at: [
+          {
+            index: 4,
+            count: 2,
+          },
+          {
+            index: -2,
+            count: 2,
+          },
+        ],
+        indent_at: [
+          {
+            first_index: 4,
+            last_index: -2,
+            count: 1,
+            separator: '  ',
+          },
+        ],
+      },
+      "BuildingSync_mapper.rb" => {
+        delete_at: [
+          {
+            index: 3,
+            count: 2,
+          },
+          {
+            index: -2,
+            count: 2,
+          },
+        ],
+        indent_at: [],
+      },
+      "BuildingSync_mapping_registry.rb" => {
+        delete_at: [
+          {
+            index: 3,
+            count: 2,
+          },
+          {
+            index: -2,
+            count: 2,
+          },
+        ],
+        indent_at: [],
+      },
+    }
+
+    # @note Download the BuildingSync XSD file from the remote network and copy to the local disk.
+    download_schema_recursive(uri_xsd_remote, verbose)
+
+    # @note Execute the "xsd2ruby.rb" binary that is installed by the "soap4r" gem.  The Ruby source files are created in the "/" directory.
+    ::Bundler.with_clean_env do
+      `xsd2ruby.rb --xsd #{::File.join("public", uri_xsd_remote.split(::File::SEPARATOR)[-1])} --module_path "BuildingSync" --classdef "BuildingSync" --mapping_registry --mapper --force --quiet`
+    end
+
+    # @note Sanitize the contents of each Ruby source file.
+    options_by_local_name.each do |local_name, options|
+      s = ::File.open(local_name, "r") do |file|
+        array = file.read.split($/)
+
+        options[:delete_at].each do |hash|
+          hash[:count].times { array.delete_at(hash[:index]) }
+        end
+
+        options[:indent_at].each do |hash|
+          array[::Range.new(hash[:first_index], hash[:last_index], false)].each do |s|
+            s.gsub!(::Regexp.new("^(.*?)$"), ::Kernel.sprintf('%s\1', ::Array.new(hash[:count], hash[:separator]).join("")))
+            s.rstrip!
+          end
+        end
+
+        array.join($/)
+      end
+
+      ::File.open(local_name, "w") do |file|
+        file.puts(s)
+      end
+    end
+
+    # @note Move the Ruby source files to the "lib/" directory.
+    options_by_local_name.keys.each do |local_name|
+      ::FileUtils.mv(local_name, ::File.join("lib", local_name)) if ::File.exist?(local_name)
+    end
+  end
+end