expressir 0.2.27-x64-mingw32 → 1.0.0-x64-mingw32

data/lib/expressir/express/subtype_constraint.rb

@@ -1,14 +0,0 @@
-require "expressir/express/model_element"
-
-module Expressir
-  module Express
-    class SubtypeConstraint < ModelElement
-      attr_accessor :name, :entity, :isAbs, :totalover, :expression
-
-      def initialize
-        @isAbs = false
-        @totalover = nil
-      end
-    end
-  end
-end

data/lib/expressir/express/type.rb

@@ -1,26 +0,0 @@
-require "expressir/express/defined_type"
-
-module Expressir
-  module Express
-    class Type < DefinedType
-      attr_accessor :isBuiltin, :domain, :isFixed, :width, :precision
-
-      def initialize(options = {})
-        @isBuiltin = false
-        @isFixed = false
-        @width = nil
-        @precision = nil
-        @wheres = []
-        @selectedBy = []
-
-        super(options)
-      end
-
-      private
-
-      def extract_type_attributes(document)
-        super(document)
-      end
-    end
-  end
-end

data/lib/expressir/express/type_aggregate.rb

@@ -1,42 +0,0 @@
-require "expressir/express/type"
-
-module Expressir
-  module Express
-    class TypeAggregate < Type
-      attr_accessor :rank, :dimensions
-      def initialize(options = {})
-        @rank = 0
-        @dimensions = []
-        @wheres = []
-        @selectedBy = []
-
-        super(options)
-      end
-
-      private
-
-      def extract_type_attributes(document)
-        @name = document.first.attributes["name"].to_s
-        @dimensions = document.map do |aggregate|
-          Express::AggregateDimension.parse(aggregate)
-        end
-
-        @rank = @dimensions.size
-        extract_builtintype_attributes(document)
-      end
-
-      def extract_builtintype_attributes(document)
-        builtin_type = document.xpath("builtintype").first
-
-        if builtin_type
-          @isBuiltin = true
-          @domain = builtin_type.attributes["type"].to_s
-          @width = builtin_type.attributes["width"].to_s
-          @fixed = builtin_type.attributes["fixed"] == "YES"
-          @precision = builtin_type.attributes["precision"].to_s
-        end
-      end
-    end
-  end
-end
-

data/lib/expressir/express/type_enum.rb

@@ -1,29 +0,0 @@
-require "expressir/express/defined_type"
-
-module Expressir
-  module Express
-    class TypeEnum < DefinedType
-      attr_accessor :items_array, :items, :extends, :extends_item,
-        :isExtensible, :allitems, :isBuiltin
-
-      def initialize(options = {})
-        @isBuiltin = false
-        @selectedBy = []
-
-        super(options)
-      end
-
-      private
-
-      def extract_type_attributes(document)
-        if document.class == Nokogiri::XML::NodeSet
-          document = document.first
-        end
-
-        @items = document.attributes["items"]
-        @items_array = items.to_s.scan(/\w+/)
-        super(document)
-      end
-    end
-  end
-end

data/lib/expressir/express/type_parser.rb

@@ -1,45 +0,0 @@
-require "expressir/express/type_enum"
-require "expressir/express/type_select"
-require "expressir/express/type_aggregate"
-
-module Expressir
-  module Express
-    class TypeParser
-      def initialize(options = {})
-        @options = options
-        @schema = options.fetch(:schema, nil)
-      end
-
-      def parse
-        document = @options.fetch(:document, nil)
-        extract_attributes(document) if document
-      end
-
-      def self.parse(document, schema)
-        new(document: document, schema: schema).parse
-      end
-
-      private
-
-      def extract_attributes(document)
-        document_with_klass = document_with_klass(document)
-        document_with_klass[:cls].parse(document_with_klass[:document], @schema)
-      end
-
-      def document_with_klass(document)
-        if !document.xpath("select").empty?
-          { document: document.xpath("select"), cls: Express::TypeSelect }
-
-        elsif !document.xpath("enumeration").empty?
-          { document: document.xpath("enumeration"), cls: Express::TypeEnum }
-
-        elsif !document.xpath("aggregate").empty?
-          { document: document.xpath("aggregate"), cls: Express::TypeAggregate }
-
-        else
-          { document: document, cls: Express::Type }
-        end
-      end
-    end
-  end
-end

data/lib/expressir/express/type_select.rb

@@ -1,82 +0,0 @@
-require "expressir/express/defined_type"
-
-module Expressir
-  module Express
-    class TypeSelect < DefinedType
-      attr_accessor :selectitems_array, :selectitems, :extends, :extends_item,
-        :isExtensible, :selectitems_all, :isGenericEntity, :isBuiltin,
-        :cleaned_select_items
-
-      def initialize(options = {})
-        @isBuiltin = false
-        @isExtensible = false
-        @isGenericEntity = false
-        @selectitems = nil
-        @selectitems_array = []
-        @cleaned_select_items = nil
-        @wheres = []
-        @selectedBy = []
-
-        super(options)
-      end
-
-      ##
-      # set cleaned_select_items = process select removing unnecessary
-      # entity types (i.e. if supertype is there)
-      #
-      def clean_select_items
-        @cleaned_select_items = ""
-
-        if selectitems != nil
-          itemname_list = selectitems.scan(/\w+/)
-          dupitem_list = []
-          for itemname in itemname_list
-            itemptr = schema.find_namedtype_by_name( itemname )
-
-            if itemptr.kind_of? EXPSM::Entity
-
-              for itemname2 in itemname_list
-                thetype = schema.find_namedtype_by_name( itemname2 )
-
-                if thetype != nil
-                  if itemptr.supertypes_all != nil &&
-                      itemptr.supertypes_all.include?(thetype.name)
-
-                    dupitem_list.push itemname
-                  end
-                end
-              end
-            end
-          end
-
-          itemname_list.each do |itemname|
-            if !dupitem_list.include? itemname
-              @cleaned_select_items = @cleaned_select_items + " " + itemname
-            end
-          end
-
-          @cleaned_select_items = @cleaned_select_items.lstrip
-        end
-      end
-
-      private
-
-      def extract_type_attributes(document)
-        if document.class == Nokogiri::XML::NodeSet
-          document = document.first
-        end
-
-        @selectitems = document.attributes["selectitems"]
-        @extends = document.attributes["basedon"]
-        @isExtensible = document.attributes["extensible"] == "YES"
-        @isGenericEntity = document.attributes["genericentity"] == "YES"
-
-        if isExtensible
-          @selectitems_all = selectitems
-        end
-
-        super(document)
-      end
-    end
-  end
-end

data/lib/expressir/express/unique_rule.rb

@@ -1,35 +0,0 @@
-require "expressir/express/model_element"
-
-module Expressir
-  module Express
-    class UniqueRule < ModelElement
-      attr_accessor :name, :attributes
-
-      def initialize(options)
-        @name = nil
-        @attributes = []
-        @options = options
-      end
-
-      def parse
-        document = @options.fetch(:document, nil)
-        extract_unique_attributes(document)
-
-        self
-      end
-
-      def self.parse(document)
-        new(document: document).parse
-      end
-
-      private
-
-      def extract_unique_attributes(document)
-        @name = document.attributes["label"].to_s
-        @attributes = document.xpath("unique.attribute").map do |attribute|
-          attribute.attributes["attribute"]
-        end
-      end
-    end
-  end
-end

data/lib/expressir/express/where_rule.rb

@@ -1,32 +0,0 @@
-require "expressir/express/model_element"
-
-module Expressir
-  module Express
-    class WhereRule < ModelElement
-      attr_accessor :name, :expression
-
-      def initialize(options = {})
-        @name = nil
-        @options = options
-      end
-
-      def parse
-        document = @options.fetch(:where, nil)
-        extract_where_attributes(document) if document
-
-        self
-      end
-
-      def self.parse(document)
-        new(document: document).parse
-      end
-
-      private
-
-      def extract_where_attributes(document)
-        @name = document.attributes["label"].to_s
-        @expression = document.attributes["expression"]
-      end
-    end
-  end
-end

data/lib/expressir/express_parser.rb

@@ -1,30 +0,0 @@
-require "expressir/parser"
-
-module Expressir
-  class ExpressParser
-    def initialize(file, options)
-      @file = file
-      @options = options
-    end
-
-    def to_owl
-      owl_parser.parse(express_xml, options)
-    end
-
-    def self.to_owl(file, **options)
-      new(file, options).to_owl
-    end
-
-    private
-
-    attr_reader :file, :options
-
-    def owl_parser
-      Expressir::Parser::OwlParser
-    end
-
-    def express_xml
-      Expressir::Express.from_xml(file)
-    end
-  end
-end

data/lib/expressir/parser.rb

@@ -1,6 +0,0 @@
-require "expressir/parser/owl_parser"
-
-module Expressir
-  module Parser
-  end
-end

data/lib/expressir/parser/owl_parser.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Parser
-    class OwlParser
-      def self.parse(express, options = {})
-      end
-    end
-  end
-end

data/spec/acceptance/express_to_owl_spec.rb

@@ -1,18 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "Expressir" do
-  describe "express-to-owl" do
-    pending "Still needs implementation"
-
-    it "convert express to owl system" do
-      command = %W(express-to-owl #{sample_file})
-      capture_stdout { Expressir::Cli.start(command) }
-    end
-  end
-
-  def sample_file
-    @sample_file ||= Expressir.root_path.join(
-      "original", "examples", "ap233", "ap233e1_arm_lf_stepmod-2010-11-12.xml"
-    )
-  end
-end

data/spec/expressir/express/repository_spec.rb

@@ -1,25 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Expressir::Express::Repository do
-  describe ".from_file" do
-    it "build an instance from a file" do
-      name = "Ap233_systems_engineering_arm_LF"
-
-      repo = Expressir::Express::Repository.from_xml(sample_file)
-      schema = repo.schemas.first
-
-      expect(repo.name).to eq(name)
-      expect(repo.schemas.count).to eq(1)
-      expect(schema.name).to eq(name)
-      expect(schema.contents.count).to eq(795)
-      expect(schema.contents.first.schema).to eq(name)
-      expect(schema.contents.first.name).to eq("Abs_function")
-    end
-  end
-
-  def sample_file
-    @sample_file ||= Expressir.root_path.join(
-      "original", "examples", "ap233", "ap233e1_arm_lf_stepmod-2010-11-12.xml"
-    )
-  end
-end

data/spec/expressir/express_exp/formatter_spec.rb

@@ -1,127 +0,0 @@
-require "yaml"
-require "spec_helper"
-require "expressir/express_exp/parser"
-require "expressir/express_exp/formatter"
-require "expressir/express_exp/schema_head_formatter"
-require "expressir/express_exp/hyperlink_formatter"
-
-RSpec.describe Expressir::ExpressExp::Formatter do
-  describe ".format" do
-    it "exports an object (single.exp)" do
-      exp_file = Expressir.root_path.join("original", "examples", "syntax", "single.exp")
-      formatted_exp_file = Expressir.root_path.join("original", "examples", "syntax", "single_formatted.exp")
-
-      repo = Expressir::ExpressExp::Parser.from_file(exp_file)
-
-      result = Expressir::ExpressExp::Formatter.format(repo)
-      # File.write(formatted_exp_file, result)
-      expected_result = File.read(formatted_exp_file)
-
-      expect(result).to eq(expected_result)
-    end
-
-    it "exports an object (multiple.exp)" do
-      exp_file = Expressir.root_path.join("original", "examples", "syntax", "multiple.exp")
-      formatted_exp_file = Expressir.root_path.join("original", "examples", "syntax", "multiple_formatted.exp")
-
-      repo = Expressir::ExpressExp::Parser.from_file(exp_file)
-
-      result = Expressir::ExpressExp::Formatter.format(repo)
-      # File.write(formatted_exp_file, result)
-      expected_result = File.read(formatted_exp_file)
-
-      expect(result).to eq(expected_result)
-    end
-
-    it "exports an object (remark.exp)" do
-      exp_file = Expressir.root_path.join("original", "examples", "syntax", "remark.exp")
-      formatted_exp_file = Expressir.root_path.join("original", "examples", "syntax", "remark_formatted.exp")
-
-      repo = Expressir::ExpressExp::Parser.from_file(exp_file)
-
-      result = Expressir::ExpressExp::Formatter.format(repo)
-      # File.write(formatted_exp_file, result)
-      expected_result = File.read(formatted_exp_file)
-
-      expect(result).to eq(expected_result)
-    end
-
-    it "exports an object (syntax.exp)" do
-      exp_file = Expressir.root_path.join("original", "examples", "syntax", "syntax.exp")
-      formatted_exp_file = Expressir.root_path.join("original", "examples", "syntax", "syntax_formatted.exp")
-
-      repo = Expressir::ExpressExp::Parser.from_file(exp_file)
-
-      result = Expressir::ExpressExp::Formatter.format(repo)
-      # File.write(formatted_exp_file, result)
-      expected_result = File.read(formatted_exp_file)
-
-      expect(result).to eq(expected_result)
-    end
-
-    it "exports an object with schema head formatter (syntax.exp)" do
-      exp_file = Expressir.root_path.join("original", "examples", "syntax", "syntax.exp")
-      formatted_exp_file = Expressir.root_path.join("original", "examples", "syntax", "syntax_schema_head_formatted.exp")
-
-      repo = Expressir::ExpressExp::Parser.from_file(exp_file)
-
-      formatter = Class.new(Expressir::ExpressExp::Formatter) do
-        include Expressir::ExpressExp::SchemaHeadFormatter
-      end
-      result = formatter.format(repo)
-      # File.write(formatted_exp_file, result)
-      expected_result = File.read(formatted_exp_file)
-
-      expect(result).to eq(expected_result)
-    end
-
-    it "exports an object with hyperlink formatter (syntax.exp)" do
-      exp_file = Expressir.root_path.join("original", "examples", "syntax", "syntax.exp")
-      formatted_exp_file = Expressir.root_path.join("original", "examples", "syntax", "syntax_hyperlink_formatted.exp")
-
-      repo = Expressir::ExpressExp::Parser.from_file(exp_file)
-
-      formatter = Class.new(Expressir::ExpressExp::Formatter) do
-        include Expressir::ExpressExp::HyperlinkFormatter
-      end
-      result = formatter.format(repo)
-      # File.write(formatted_exp_file, result)
-      expected_result = File.read(formatted_exp_file)
-
-      expect(result).to eq(expected_result)
-    end
-
-    it "exports an object with hyperlink formatter (multiple.exp)" do
-      exp_file = Expressir.root_path.join("original", "examples", "syntax", "multiple.exp")
-      formatted_exp_file = Expressir.root_path.join("original", "examples", "syntax", "multiple_hyperlink_formatted.exp")
-
-      repo = Expressir::ExpressExp::Parser.from_file(exp_file)
-
-      formatter = Class.new(Expressir::ExpressExp::Formatter) do
-        include Expressir::ExpressExp::HyperlinkFormatter
-      end
-      result = formatter.format(repo)
-      # File.write(formatted_exp_file, result)
-      expected_result = File.read(formatted_exp_file)
-
-      expect(result).to eq(expected_result)
-    end
-
-    it "exports an object with schema head and hyperlink formatter (multiple.exp)" do
-      exp_file = Expressir.root_path.join("original", "examples", "syntax", "multiple.exp")
-      formatted_exp_file = Expressir.root_path.join("original", "examples", "syntax", "multiple_schema_head_hyperlink_formatted.exp")
-
-      repo = Expressir::ExpressExp::Parser.from_file(exp_file)
-
-      formatter = Class.new(Expressir::ExpressExp::Formatter) do
-        include Expressir::ExpressExp::SchemaHeadFormatter
-        include Expressir::ExpressExp::HyperlinkFormatter
-      end
-      result = formatter.format(repo)
-      # File.write(formatted_exp_file, result)
-      expected_result = File.read(formatted_exp_file)
-
-      expect(result).to eq(expected_result)
-    end
-  end
-end