expressir 0.2.24 → 1.1.0

data/lib/expressir/model/supertype_expressions/binary_supertype_expression.rb

@@ -0,0 +1,29 @@
+module Expressir
+  module Model
+    module SupertypeExpressions
+      # Specified in ISO 10303-11:2004
+      # - section 9.2.5.3 ANDOR
+      # - section 9.2.5.4 AND
+      class BinarySupertypeExpression < SupertypeExpression
+        AND = :AND
+        ANDOR = :ANDOR
+
+        model_attr_accessor :operator, ':AND, :ANDOR'
+        model_attr_accessor :operand1, 'SupertypeExpression'
+        model_attr_accessor :operand2, 'SupertypeExpression'
+
+        # @param [Hash] options
+        # @option options [:AND, :ANDOR] :operator
+        # @option options [SupertypeExpression] :operand1
+        # @option options [SupertypeExpression] :operand2
+        def initialize(options = {})
+          @operator = options[:operator]
+          @operand1 = options[:operand1]
+          @operand2 = options[:operand2]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/supertype_expressions/oneof_supertype_expression.rb

@@ -0,0 +1,19 @@
+module Expressir
+  module Model
+    module SupertypeExpressions
+      # Specified in ISO 10303-11:2004
+      # - section 9.2.5.2 ONEOF
+      class OneofSupertypeExpression < SupertypeExpression
+        model_attr_accessor :operands, 'Array<SupertypeExpression>'
+
+        # @param [Hash] options
+        # @option options [Array<SupertypeExpression>] :operands
+        def initialize(options = {})
+          @operands = options[:operands]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/version.rb

@@ -1,3 +1,3 @@
 module Expressir
-  VERSION = "0.2.24".freeze
+  VERSION = "1.1.0".freeze
 end

data/rakelib/cross-ruby.rake

@@ -296,7 +296,7 @@ require "rake/extensiontask"
 
 Rake::ExtensionTask.new("express_parser", GEMSPEC) do |ext|
   ext.ext_dir = "ext/express-parser"
-  ext.lib_dir = File.join(*['lib', 'expressir', 'express_exp', ENV['FAT_DIR']].compact)
+  ext.lib_dir = File.join(*['lib', 'expressir', 'express', ENV['FAT_DIR']].compact)
   ext.config_options << ENV['EXTOPTS']
   ext.cross_compile  = true
   ext.cross_platform = CROSS_RUBIES.map(&:platform).uniq

data/spec/expressir/{express_exp → express}/cache_spec.rb

@@ -1,10 +1,10 @@
 require "yaml"
 require "tempfile"
 require "spec_helper"
-require "expressir/express_exp/parser"
-require "expressir/express_exp/cache"
+require "expressir/express/parser"
+require "expressir/express/cache"
 
-RSpec.describe Expressir::ExpressExp::Cache do
+RSpec.describe Expressir::Express::Cache do
   TEST_VERSION = "0.0.0"
 
   describe ".to_file" do
@@ -14,7 +14,7 @@ RSpec.describe Expressir::ExpressExp::Cache do
       repository = Expressir::Model::Repository.new
 
       begin
-        Expressir::ExpressExp::Cache.to_file(temp_file, repository, test_overwrite_version: TEST_VERSION)
+        Expressir::Express::Cache.to_file(temp_file, repository, test_overwrite_version: TEST_VERSION)
 
         size = File.size(temp_file)
 
@@ -33,9 +33,9 @@ RSpec.describe Expressir::ExpressExp::Cache do
       repository = Expressir::Model::Repository.new
 
       begin
-        Expressir::ExpressExp::Cache.to_file(temp_file, repository, test_overwrite_version: TEST_VERSION)
+        Expressir::Express::Cache.to_file(temp_file, repository, test_overwrite_version: TEST_VERSION)
 
-        result = Expressir::ExpressExp::Cache.from_file(temp_file, test_overwrite_version: TEST_VERSION)
+        result = Expressir::Express::Cache.from_file(temp_file, test_overwrite_version: TEST_VERSION)
 
         expect(result).to be_instance_of(Expressir::Model::Repository)
       ensure
@@ -50,11 +50,11 @@ RSpec.describe Expressir::ExpressExp::Cache do
       repository = Expressir::Model::Repository.new
 
       begin
-        Expressir::ExpressExp::Cache.to_file(temp_file, repository, test_overwrite_version: TEST_VERSION)
+        Expressir::Express::Cache.to_file(temp_file, repository, test_overwrite_version: TEST_VERSION)
 
         expect do
-          Expressir::ExpressExp::Cache.from_file(temp_file)
-        end.to raise_error(Expressir::ExpressExp::CacheLoadError)
+          Expressir::Express::Cache.from_file(temp_file)
+        end.to raise_error(Expressir::Error)
       ensure
         temp_file.close
         temp_file.unlink

data/spec/expressir/express/formatter_spec.rb

@@ -0,0 +1,127 @@
+require "yaml"
+require "spec_helper"
+require "expressir/express/parser"
+require "expressir/express/formatter"
+require "expressir/express/schema_head_formatter"
+require "expressir/express/hyperlink_formatter"
+
+RSpec.describe Expressir::Express::Formatter do
+  describe ".format" do
+    it "exports an object (single.exp)" do
+      exp_file = Expressir.root_path.join("spec", "syntax", "single.exp")
+      formatted_exp_file = Expressir.root_path.join("spec", "syntax", "single_formatted.exp")
+
+      repo = Expressir::Express::Parser.from_file(exp_file)
+
+      result = Expressir::Express::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("spec", "syntax", "multiple.exp")
+      formatted_exp_file = Expressir.root_path.join("spec", "syntax", "multiple_formatted.exp")
+
+      repo = Expressir::Express::Parser.from_file(exp_file)
+
+      result = Expressir::Express::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("spec", "syntax", "remark.exp")
+      formatted_exp_file = Expressir.root_path.join("spec", "syntax", "remark_formatted.exp")
+
+      repo = Expressir::Express::Parser.from_file(exp_file)
+
+      result = Expressir::Express::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("spec", "syntax", "syntax.exp")
+      formatted_exp_file = Expressir.root_path.join("spec", "syntax", "syntax_formatted.exp")
+
+      repo = Expressir::Express::Parser.from_file(exp_file)
+
+      result = Expressir::Express::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("spec", "syntax", "syntax.exp")
+      formatted_exp_file = Expressir.root_path.join("spec", "syntax", "syntax_schema_head_formatted.exp")
+
+      repo = Expressir::Express::Parser.from_file(exp_file)
+
+      formatter = Class.new(Expressir::Express::Formatter) do
+        include Expressir::Express::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("spec", "syntax", "syntax.exp")
+      formatted_exp_file = Expressir.root_path.join("spec", "syntax", "syntax_hyperlink_formatted.exp")
+
+      repo = Expressir::Express::Parser.from_file(exp_file)
+
+      formatter = Class.new(Expressir::Express::Formatter) do
+        include Expressir::Express::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("spec", "syntax", "multiple.exp")
+      formatted_exp_file = Expressir.root_path.join("spec", "syntax", "multiple_hyperlink_formatted.exp")
+
+      repo = Expressir::Express::Parser.from_file(exp_file)
+
+      formatter = Class.new(Expressir::Express::Formatter) do
+        include Expressir::Express::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("spec", "syntax", "multiple.exp")
+      formatted_exp_file = Expressir.root_path.join("spec", "syntax", "multiple_schema_head_hyperlink_formatted.exp")
+
+      repo = Expressir::Express::Parser.from_file(exp_file)
+
+      formatter = Class.new(Expressir::Express::Formatter) do
+        include Expressir::Express::SchemaHeadFormatter
+        include Expressir::Express::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

data/spec/expressir/{express_exp → express}/parser_spec.rb

@@ -1,15 +1,15 @@
 require "yaml"
 require "spec_helper"
-require "expressir/express_exp/parser"
+require "expressir/express/parser"
 
-RSpec.describe Expressir::ExpressExp::Parser do
+RSpec.describe Expressir::Express::Parser do
   describe ".from_file" do
     it "parses a file (single.exp)" do
-      exp_file = Expressir.root_path.join("original", "examples", "syntax", "single.exp")
-      yaml_file = Expressir.root_path.join("original", "examples", "syntax", "single.yaml")
+      exp_file = Expressir.root_path.join("spec", "syntax", "single.exp")
+      yaml_file = Expressir.root_path.join("spec", "syntax", "single.yaml")
 
-      repo = Expressir::ExpressExp::Parser.from_file(exp_file)
-      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path, skip_empty: true))
+      repo = Expressir::Express::Parser.from_file(exp_file)
+      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path))
       # File.write(yaml_file, result)
       expected_result = File.read(yaml_file)
       
@@ -17,11 +17,11 @@ RSpec.describe Expressir::ExpressExp::Parser do
     end
 
     it "parses a file (multiple.exp)" do
-      exp_file = Expressir.root_path.join("original", "examples", "syntax", "multiple.exp")
-      yaml_file = Expressir.root_path.join("original", "examples", "syntax", "multiple.yaml")
+      exp_file = Expressir.root_path.join("spec", "syntax", "multiple.exp")
+      yaml_file = Expressir.root_path.join("spec", "syntax", "multiple.yaml")
 
-      repo = Expressir::ExpressExp::Parser.from_file(exp_file)
-      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path, skip_empty: true))
+      repo = Expressir::Express::Parser.from_file(exp_file)
+      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path))
       # File.write(yaml_file, result)
       expected_result = File.read(yaml_file)
       
@@ -29,11 +29,11 @@ RSpec.describe Expressir::ExpressExp::Parser do
     end
 
     it "parses a file (syntax.exp)" do
-      exp_file = Expressir.root_path.join("original", "examples", "syntax", "syntax.exp")
-      yaml_file = Expressir.root_path.join("original", "examples", "syntax", "syntax.yaml")
+      exp_file = Expressir.root_path.join("spec", "syntax", "syntax.exp")
+      yaml_file = Expressir.root_path.join("spec", "syntax", "syntax.yaml")
 
-      repo = Expressir::ExpressExp::Parser.from_file(exp_file)
-      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path, skip_empty: true))
+      repo = Expressir::Express::Parser.from_file(exp_file)
+      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path))
       # File.write(yaml_file, result)
       expected_result = File.read(yaml_file)
       
@@ -41,11 +41,11 @@ RSpec.describe Expressir::ExpressExp::Parser do
     end
 
     it "parses a file (remark.exp)" do
-      exp_file = Expressir.root_path.join("original", "examples", "syntax", "remark.exp")
-      yaml_file = Expressir.root_path.join("original", "examples", "syntax", "remark.yaml")
+      exp_file = Expressir.root_path.join("spec", "syntax", "remark.exp")
+      yaml_file = Expressir.root_path.join("spec", "syntax", "remark.yaml")
 
-      repo = Expressir::ExpressExp::Parser.from_file(exp_file)
-      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path, skip_empty: true))
+      repo = Expressir::Express::Parser.from_file(exp_file)
+      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path))
       # File.write(yaml_file, result)
       expected_result = File.read(yaml_file)
       
@@ -53,10 +53,10 @@ RSpec.describe Expressir::ExpressExp::Parser do
     end
 
     it "parses a file including original source (multiple.exp)" do
-      exp_file = Expressir.root_path.join("original", "examples", "syntax", "multiple.exp")
+      exp_file = Expressir.root_path.join("spec", "syntax", "multiple.exp")
 
       input = File.read(exp_file)
-      repo = Expressir::ExpressExp::Parser.from_file(exp_file, include_source: true)
+      repo = Expressir::Express::Parser.from_file(exp_file, include_source: true)
 
       schema = repo.schemas.first
       start_index = input.index("SCHEMA")
@@ -75,18 +75,18 @@ RSpec.describe Expressir::ExpressExp::Parser do
   describe ".from_files" do
     it "parses multiple files (single.exp, multiple.exp)" do
       exp_files = [
-        Expressir.root_path.join("original", "examples", "syntax", "single.exp"),
-        Expressir.root_path.join("original", "examples", "syntax", "multiple.exp")
+        Expressir.root_path.join("spec", "syntax", "single.exp"),
+        Expressir.root_path.join("spec", "syntax", "multiple.exp")
       ]
 
-      repo = Expressir::ExpressExp::Parser.from_files(exp_files)
+      repo = Expressir::Express::Parser.from_files(exp_files)
 
       schemas = repo.schemas
       expect(schemas.count).to eq(5)
       expect(schemas[0].file).to eq(exp_files[0].to_s)
       expect(schemas[0].id).to eq("single_schema")
       expect(schemas[1].file).to eq(exp_files[1].to_s)
-      expect(schemas[1].id).to eq("multiple_schema1")
+      expect(schemas[1].id).to eq("multiple_schema")
       expect(schemas[2].file).to eq(exp_files[1].to_s)
       expect(schemas[2].id).to eq("multiple_schema2")
       expect(schemas[3].file).to eq(exp_files[1].to_s)

data/spec/expressir/model/model_element_spec.rb

@@ -1,18 +1,18 @@
 
 require "yaml"
 require "spec_helper"
-require "expressir/express_exp/parser"
-require "expressir/express_exp/formatter"
+require "expressir/express/parser"
+require "expressir/express/formatter"
 
 RSpec.describe Expressir::Model::ModelElement do
   describe ".to_hash" do
     it "exports an object with a formatter (single.exp)" do
-      exp_file = Expressir.root_path.join("original", "examples", "syntax", "single.exp")
-      yaml_file = Expressir.root_path.join("original", "examples", "syntax", "single_formatted.yaml")
+      exp_file = Expressir.root_path.join("spec", "syntax", "single.exp")
+      yaml_file = Expressir.root_path.join("spec", "syntax", "single_formatted.yaml")
 
-      repo = Expressir::ExpressExp::Parser.from_file(exp_file)
+      repo = Expressir::Express::Parser.from_file(exp_file)
 
-      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path, formatter: Expressir::ExpressExp::Formatter, skip_empty: true))
+      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path, formatter: Expressir::Express::Formatter))
       # File.write(yaml_file, result)
       expected_result = File.read(yaml_file)
       
@@ -22,48 +22,48 @@ RSpec.describe Expressir::Model::ModelElement do
 
   describe ".from_hash" do
     it "parses an object (single.yaml)" do
-      yaml_file = Expressir.root_path.join("original", "examples", "syntax", "single.yaml")
+      yaml_file = Expressir.root_path.join("spec", "syntax", "single.yaml")
 
       input = YAML.load(File.read(yaml_file))
       repo = Expressir::Model::ModelElement.from_hash(input, root_path: Expressir.root_path)
 
-      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path, skip_empty: true))
+      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path))
       expected_result = File.read(yaml_file)
 
       expect(result).to eq(expected_result)
     end
 
     it "parses an object (multiple.yaml)" do
-      yaml_file = Expressir.root_path.join("original", "examples", "syntax", "multiple.yaml")
+      yaml_file = Expressir.root_path.join("spec", "syntax", "multiple.yaml")
 
       input = YAML.load(File.read(yaml_file))
       repo = Expressir::Model::ModelElement.from_hash(input, root_path: Expressir.root_path)
 
-      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path, skip_empty: true))
+      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path))
       expected_result = File.read(yaml_file)
 
       expect(result).to eq(expected_result)
     end
 
     it "parses an object (syntax.yaml)" do
-      yaml_file = Expressir.root_path.join("original", "examples", "syntax", "syntax.yaml")
+      yaml_file = Expressir.root_path.join("spec", "syntax", "syntax.yaml")
 
       input = YAML.load(File.read(yaml_file))
       repo = Expressir::Model::ModelElement.from_hash(input, root_path: Expressir.root_path)
 
-      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path, skip_empty: true))
+      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path))
       expected_result = File.read(yaml_file)
 
       expect(result).to eq(expected_result)
     end
 
     it "parses an object (remark.yaml)" do
-      yaml_file = Expressir.root_path.join("original", "examples", "syntax", "remark.yaml")
+      yaml_file = Expressir.root_path.join("spec", "syntax", "remark.yaml")
 
       input = YAML.load(File.read(yaml_file))
       repo = Expressir::Model::ModelElement.from_hash(input, root_path: Expressir.root_path)
 
-      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path, skip_empty: true))
+      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path))
       expected_result = File.read(yaml_file)
 
       expect(result).to eq(expected_result)
@@ -71,144 +71,196 @@ RSpec.describe Expressir::Model::ModelElement do
   end
 
   describe ".find" do
-    it "finds an object" do
-      exp_file = Expressir.root_path.join("original", "examples", "syntax", "remark.exp")
+    it "finds an object (single.exp)" do
+      exp_file = Expressir.root_path.join("spec", "syntax", "single.exp")
 
-      repo = Expressir::ExpressExp::Parser.from_file(exp_file)
+      repo = Expressir::Express::Parser.from_file(exp_file)
 
       # universal scope
-      expect(repo.find('remark_schema')).to be_instance_of(Expressir::Model::Schema)
-      expect(repo.find('remark_schema.remark_constant')).to be_instance_of(Expressir::Model::Constant)
-      expect(repo.find('remark_schema.remark_type')).to be_instance_of(Expressir::Model::Type)
-      expect(repo.find('remark_schema.remark_type.WR1')).to be_instance_of(Expressir::Model::Where)
-      expect(repo.find('remark_schema.remark_type.wr:WR1')).to be_instance_of(Expressir::Model::Where)
-      expect(repo.find('remark_schema.remark_type.IP1')).to be_instance_of(Expressir::Model::RemarkItem)
-      expect(repo.find('remark_schema.remark_type.ip:IP1')).to be_instance_of(Expressir::Model::RemarkItem)
-      expect(repo.find('remark_schema.remark_enumeration_item')).to be_instance_of(Expressir::Model::EnumerationItem)
-      expect(repo.find('remark_schema.remark_entity')).to be_instance_of(Expressir::Model::Entity)
-      expect(repo.find('remark_schema.remark_entity.remark_attribute')).to be_instance_of(Expressir::Model::Attribute)
-      expect(repo.find('remark_schema.remark_entity.remark_derived_attribute')).to be_instance_of(Expressir::Model::Attribute)
-      expect(repo.find('remark_schema.remark_entity.remark_inverse_attribute')).to be_instance_of(Expressir::Model::Attribute)
-      expect(repo.find('remark_schema.remark_entity.UR1')).to be_instance_of(Expressir::Model::Unique)
-      expect(repo.find('remark_schema.remark_entity.WR1')).to be_instance_of(Expressir::Model::Where)
-      expect(repo.find('remark_schema.remark_entity.wr:WR1')).to be_instance_of(Expressir::Model::Where)
-      expect(repo.find('remark_schema.remark_entity.IP1')).to be_instance_of(Expressir::Model::RemarkItem)
-      expect(repo.find('remark_schema.remark_entity.ip:IP1')).to be_instance_of(Expressir::Model::RemarkItem)
-      expect(repo.find('remark_schema.remark_subtype_constraint')).to be_instance_of(Expressir::Model::SubtypeConstraint)
-      expect(repo.find('remark_schema.remark_function')).to be_instance_of(Expressir::Model::Function)
-      expect(repo.find('remark_schema.remark_function.remark_parameter')).to be_instance_of(Expressir::Model::Parameter)
-      expect(repo.find('remark_schema.remark_function.remark_type')).to be_instance_of(Expressir::Model::Type)
-      expect(repo.find('remark_schema.remark_function.remark_enumeration_item')).to be_instance_of(Expressir::Model::EnumerationItem)
-      expect(repo.find('remark_schema.remark_function.remark_constant')).to be_instance_of(Expressir::Model::Constant)
-      expect(repo.find('remark_schema.remark_function.remark_variable')).to be_instance_of(Expressir::Model::Variable)
-      expect(repo.find('remark_schema.remark_procedure')).to be_instance_of(Expressir::Model::Procedure)
-      expect(repo.find('remark_schema.remark_procedure.remark_parameter')).to be_instance_of(Expressir::Model::Parameter)
-      expect(repo.find('remark_schema.remark_procedure.remark_type')).to be_instance_of(Expressir::Model::Type)
-      expect(repo.find('remark_schema.remark_procedure.remark_enumeration_item')).to be_instance_of(Expressir::Model::EnumerationItem)
-      expect(repo.find('remark_schema.remark_procedure.remark_constant')).to be_instance_of(Expressir::Model::Constant)
-      expect(repo.find('remark_schema.remark_procedure.remark_variable')).to be_instance_of(Expressir::Model::Variable)
-      expect(repo.find('remark_schema.remark_rule')).to be_instance_of(Expressir::Model::Rule)
-      expect(repo.find('remark_schema.remark_rule.remark_type')).to be_instance_of(Expressir::Model::Type)
-      expect(repo.find('remark_schema.remark_rule.remark_enumeration_item')).to be_instance_of(Expressir::Model::EnumerationItem)
-      expect(repo.find('remark_schema.remark_rule.remark_constant')).to be_instance_of(Expressir::Model::Constant)
-      expect(repo.find('remark_schema.remark_rule.remark_variable')).to be_instance_of(Expressir::Model::Variable)
-      expect(repo.find('remark_schema.remark_rule.WR1')).to be_instance_of(Expressir::Model::Where)
-      expect(repo.find('remark_schema.remark_rule.wr:WR1')).to be_instance_of(Expressir::Model::Where)
-      expect(repo.find('remark_schema.remark_rule.IP1')).to be_instance_of(Expressir::Model::RemarkItem)
-      expect(repo.find('remark_schema.remark_rule.ip:IP1')).to be_instance_of(Expressir::Model::RemarkItem)
+      expect(repo.find('single_schema')).to be_instance_of(Expressir::Model::Declarations::Schema)
+      expect(repo.find('single_schema.empty_entity')).to be_instance_of(Expressir::Model::Declarations::Entity)
 
       # schema scope
       schema = repo.schemas.first
-      expect(schema.find('remark_constant')).to be_instance_of(Expressir::Model::Constant)
-      expect(schema.find('remark_type')).to be_instance_of(Expressir::Model::Type)
-      expect(schema.find('remark_type.WR1')).to be_instance_of(Expressir::Model::Where)
-      expect(schema.find('remark_type.wr:WR1')).to be_instance_of(Expressir::Model::Where)
-      expect(schema.find('remark_type.IP1')).to be_instance_of(Expressir::Model::RemarkItem)
-      expect(schema.find('remark_type.ip:IP1')).to be_instance_of(Expressir::Model::RemarkItem)
-      expect(schema.find('remark_enumeration_item')).to be_instance_of(Expressir::Model::EnumerationItem)
-      expect(schema.find('remark_entity')).to be_instance_of(Expressir::Model::Entity)
-      expect(schema.find('remark_entity.remark_attribute')).to be_instance_of(Expressir::Model::Attribute)
-      expect(schema.find('remark_entity.remark_derived_attribute')).to be_instance_of(Expressir::Model::Attribute)
-      expect(schema.find('remark_entity.remark_inverse_attribute')).to be_instance_of(Expressir::Model::Attribute)
-      expect(schema.find('remark_entity.UR1')).to be_instance_of(Expressir::Model::Unique)
-      expect(schema.find('remark_entity.WR1')).to be_instance_of(Expressir::Model::Where)
-      expect(schema.find('remark_entity.wr:WR1')).to be_instance_of(Expressir::Model::Where)
-      expect(schema.find('remark_entity.IP1')).to be_instance_of(Expressir::Model::RemarkItem)
-      expect(schema.find('remark_entity.ip:IP1')).to be_instance_of(Expressir::Model::RemarkItem)
-      expect(schema.find('remark_subtype_constraint')).to be_instance_of(Expressir::Model::SubtypeConstraint)
-      expect(schema.find('remark_function')).to be_instance_of(Expressir::Model::Function)
-      expect(schema.find('remark_function.remark_parameter')).to be_instance_of(Expressir::Model::Parameter)
-      expect(schema.find('remark_function.remark_type')).to be_instance_of(Expressir::Model::Type)
-      expect(schema.find('remark_function.remark_enumeration_item')).to be_instance_of(Expressir::Model::EnumerationItem)
-      expect(schema.find('remark_function.remark_constant')).to be_instance_of(Expressir::Model::Constant)
-      expect(schema.find('remark_function.remark_variable')).to be_instance_of(Expressir::Model::Variable)
-      expect(schema.find('remark_procedure')).to be_instance_of(Expressir::Model::Procedure)
-      expect(schema.find('remark_procedure.remark_parameter')).to be_instance_of(Expressir::Model::Parameter)
-      expect(schema.find('remark_procedure.remark_type')).to be_instance_of(Expressir::Model::Type)
-      expect(schema.find('remark_procedure.remark_enumeration_item')).to be_instance_of(Expressir::Model::EnumerationItem)
-      expect(schema.find('remark_procedure.remark_constant')).to be_instance_of(Expressir::Model::Constant)
-      expect(schema.find('remark_procedure.remark_variable')).to be_instance_of(Expressir::Model::Variable)
-      expect(schema.find('remark_rule')).to be_instance_of(Expressir::Model::Rule)
-      expect(schema.find('remark_rule.remark_type')).to be_instance_of(Expressir::Model::Type)
-      expect(schema.find('remark_rule.remark_enumeration_item')).to be_instance_of(Expressir::Model::EnumerationItem)
-      expect(schema.find('remark_rule.remark_constant')).to be_instance_of(Expressir::Model::Constant)
-      expect(schema.find('remark_rule.remark_variable')).to be_instance_of(Expressir::Model::Variable)
-      expect(schema.find('remark_rule.WR1')).to be_instance_of(Expressir::Model::Where)
-      expect(schema.find('remark_rule.wr:WR1')).to be_instance_of(Expressir::Model::Where)
-      expect(schema.find('remark_rule.IP1')).to be_instance_of(Expressir::Model::RemarkItem)
-      expect(schema.find('remark_rule.ip:IP1')).to be_instance_of(Expressir::Model::RemarkItem)
+      expect(schema.find('empty_entity')).to be_instance_of(Expressir::Model::Declarations::Entity)
+    end
+
+    it "finds an object (multiple.exp)" do
+      exp_file = Expressir.root_path.join("spec", "syntax", "multiple.exp")
+
+      repo = Expressir::Express::Parser.from_file(exp_file)
+
+      # universal scope
+      expect(repo.find('multiple_schema')).to be_instance_of(Expressir::Model::Declarations::Schema)
+      expect(repo.find('multiple_schema.empty_entity')).to be_instance_of(Expressir::Model::Declarations::Entity)
+      expect(repo.find('multiple_schema.attribute_entity')).to be_instance_of(Expressir::Model::Declarations::Entity)
+      expect(repo.find('multiple_schema.attribute_entity2')).to be_instance_of(Expressir::Model::Declarations::Entity)
+      expect(repo.find('multiple_schema.attribute_entity3')).to be_instance_of(Expressir::Model::Declarations::Entity)
+      expect(repo.find('multiple_schema.attribute_entity4')).to be_instance_of(Expressir::Model::Declarations::Entity)
+
+      # schema scope
+      schema = repo.schemas.first
+      expect(schema.find('empty_entity')).to be_instance_of(Expressir::Model::Declarations::Entity)
+      expect(schema.find('attribute_entity')).to be_instance_of(Expressir::Model::Declarations::Entity)
+      expect(schema.find('attribute_entity2')).to be_instance_of(Expressir::Model::Declarations::Entity)
+      expect(schema.find('attribute_entity3')).to be_instance_of(Expressir::Model::Declarations::Entity)
+      expect(schema.find('attribute_entity4')).to be_instance_of(Expressir::Model::Declarations::Entity)
+    end
+
+    it "finds an object (syntax.exp)" do
+      exp_file = Expressir.root_path.join("spec", "syntax", "syntax.exp")
+
+      repo = Expressir::Express::Parser.from_file(exp_file)
+
+      # universal scope
+      expect(repo.find('syntax_schema')).to be_instance_of(Expressir::Model::Declarations::Schema)
+      expect(repo.find('syntax_schema.empty_entity')).to be_instance_of(Expressir::Model::Declarations::Entity)
+
+      # schema scope
+      schema = repo.schemas.first
+      expect(schema.find('empty_entity')).to be_instance_of(Expressir::Model::Declarations::Entity)
+    end
+
+    it "finds an object (remark.exp)" do
+      exp_file = Expressir.root_path.join("spec", "syntax", "remark.exp")
+
+      repo = Expressir::Express::Parser.from_file(exp_file)
+
+      # universal scope
+      expect(repo.find('remark_schema')).to be_instance_of(Expressir::Model::Declarations::Schema)
+      expect(repo.find('remark_schema.remark_constant')).to be_instance_of(Expressir::Model::Declarations::Constant)
+      expect(repo.find('remark_schema.remark_type')).to be_instance_of(Expressir::Model::Declarations::Type)
+      expect(repo.find('remark_schema.remark_type.WR1')).to be_instance_of(Expressir::Model::Declarations::WhereRule)
+      expect(repo.find('remark_schema.remark_type.wr:WR1')).to be_instance_of(Expressir::Model::Declarations::WhereRule)
+      expect(repo.find('remark_schema.remark_type.IP1')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
+      expect(repo.find('remark_schema.remark_type.ip:IP1')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
+      expect(repo.find('remark_schema.remark_enumeration_item')).to be_instance_of(Expressir::Model::DataTypes::EnumerationItem)
+      expect(repo.find('remark_schema.remark_entity')).to be_instance_of(Expressir::Model::Declarations::Entity)
+      expect(repo.find('remark_schema.remark_entity.remark_attribute')).to be_instance_of(Expressir::Model::Declarations::Attribute)
+      expect(repo.find('remark_schema.remark_entity.remark_derived_attribute')).to be_instance_of(Expressir::Model::Declarations::Attribute)
+      expect(repo.find('remark_schema.remark_entity.remark_inverse_attribute')).to be_instance_of(Expressir::Model::Declarations::Attribute)
+      expect(repo.find('remark_schema.remark_entity.UR1')).to be_instance_of(Expressir::Model::Declarations::UniqueRule)
+      expect(repo.find('remark_schema.remark_entity.WR1')).to be_instance_of(Expressir::Model::Declarations::WhereRule)
+      expect(repo.find('remark_schema.remark_entity.wr:WR1')).to be_instance_of(Expressir::Model::Declarations::WhereRule)
+      expect(repo.find('remark_schema.remark_entity.IP1')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
+      expect(repo.find('remark_schema.remark_entity.ip:IP1')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
+      expect(repo.find('remark_schema.remark_subtype_constraint')).to be_instance_of(Expressir::Model::Declarations::SubtypeConstraint)
+      expect(repo.find('remark_schema.remark_function')).to be_instance_of(Expressir::Model::Declarations::Function)
+      expect(repo.find('remark_schema.remark_function.remark_parameter')).to be_instance_of(Expressir::Model::Declarations::Parameter)
+      expect(repo.find('remark_schema.remark_function.remark_type')).to be_instance_of(Expressir::Model::Declarations::Type)
+      expect(repo.find('remark_schema.remark_function.remark_enumeration_item')).to be_instance_of(Expressir::Model::DataTypes::EnumerationItem)
+      expect(repo.find('remark_schema.remark_function.remark_constant')).to be_instance_of(Expressir::Model::Declarations::Constant)
+      expect(repo.find('remark_schema.remark_function.remark_variable')).to be_instance_of(Expressir::Model::Declarations::Variable)
+      expect(repo.find('remark_schema.remark_procedure')).to be_instance_of(Expressir::Model::Declarations::Procedure)
+      expect(repo.find('remark_schema.remark_procedure.remark_parameter')).to be_instance_of(Expressir::Model::Declarations::Parameter)
+      expect(repo.find('remark_schema.remark_procedure.remark_type')).to be_instance_of(Expressir::Model::Declarations::Type)
+      expect(repo.find('remark_schema.remark_procedure.remark_enumeration_item')).to be_instance_of(Expressir::Model::DataTypes::EnumerationItem)
+      expect(repo.find('remark_schema.remark_procedure.remark_constant')).to be_instance_of(Expressir::Model::Declarations::Constant)
+      expect(repo.find('remark_schema.remark_procedure.remark_variable')).to be_instance_of(Expressir::Model::Declarations::Variable)
+      expect(repo.find('remark_schema.remark_rule')).to be_instance_of(Expressir::Model::Declarations::Rule)
+      expect(repo.find('remark_schema.remark_rule.remark_type')).to be_instance_of(Expressir::Model::Declarations::Type)
+      expect(repo.find('remark_schema.remark_rule.remark_enumeration_item')).to be_instance_of(Expressir::Model::DataTypes::EnumerationItem)
+      expect(repo.find('remark_schema.remark_rule.remark_constant')).to be_instance_of(Expressir::Model::Declarations::Constant)
+      expect(repo.find('remark_schema.remark_rule.remark_variable')).to be_instance_of(Expressir::Model::Declarations::Variable)
+      expect(repo.find('remark_schema.remark_rule.WR1')).to be_instance_of(Expressir::Model::Declarations::WhereRule)
+      expect(repo.find('remark_schema.remark_rule.wr:WR1')).to be_instance_of(Expressir::Model::Declarations::WhereRule)
+      expect(repo.find('remark_schema.remark_rule.IP1')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
+      expect(repo.find('remark_schema.remark_rule.ip:IP1')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
+      expect(repo.find('remark_schema.remark_item')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
+
+      # schema scope
+      schema = repo.schemas.first
+      expect(schema.find('remark_constant')).to be_instance_of(Expressir::Model::Declarations::Constant)
+      expect(schema.find('remark_type')).to be_instance_of(Expressir::Model::Declarations::Type)
+      expect(schema.find('remark_type.WR1')).to be_instance_of(Expressir::Model::Declarations::WhereRule)
+      expect(schema.find('remark_type.wr:WR1')).to be_instance_of(Expressir::Model::Declarations::WhereRule)
+      expect(schema.find('remark_type.IP1')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
+      expect(schema.find('remark_type.ip:IP1')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
+      expect(schema.find('remark_enumeration_item')).to be_instance_of(Expressir::Model::DataTypes::EnumerationItem)
+      expect(schema.find('remark_entity')).to be_instance_of(Expressir::Model::Declarations::Entity)
+      expect(schema.find('remark_entity.remark_attribute')).to be_instance_of(Expressir::Model::Declarations::Attribute)
+      expect(schema.find('remark_entity.remark_derived_attribute')).to be_instance_of(Expressir::Model::Declarations::Attribute)
+      expect(schema.find('remark_entity.remark_inverse_attribute')).to be_instance_of(Expressir::Model::Declarations::Attribute)
+      expect(schema.find('remark_entity.UR1')).to be_instance_of(Expressir::Model::Declarations::UniqueRule)
+      expect(schema.find('remark_entity.WR1')).to be_instance_of(Expressir::Model::Declarations::WhereRule)
+      expect(schema.find('remark_entity.wr:WR1')).to be_instance_of(Expressir::Model::Declarations::WhereRule)
+      expect(schema.find('remark_entity.IP1')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
+      expect(schema.find('remark_entity.ip:IP1')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
+      expect(schema.find('remark_subtype_constraint')).to be_instance_of(Expressir::Model::Declarations::SubtypeConstraint)
+      expect(schema.find('remark_function')).to be_instance_of(Expressir::Model::Declarations::Function)
+      expect(schema.find('remark_function.remark_parameter')).to be_instance_of(Expressir::Model::Declarations::Parameter)
+      expect(schema.find('remark_function.remark_type')).to be_instance_of(Expressir::Model::Declarations::Type)
+      expect(schema.find('remark_function.remark_enumeration_item')).to be_instance_of(Expressir::Model::DataTypes::EnumerationItem)
+      expect(schema.find('remark_function.remark_constant')).to be_instance_of(Expressir::Model::Declarations::Constant)
+      expect(schema.find('remark_function.remark_variable')).to be_instance_of(Expressir::Model::Declarations::Variable)
+      expect(schema.find('remark_procedure')).to be_instance_of(Expressir::Model::Declarations::Procedure)
+      expect(schema.find('remark_procedure.remark_parameter')).to be_instance_of(Expressir::Model::Declarations::Parameter)
+      expect(schema.find('remark_procedure.remark_type')).to be_instance_of(Expressir::Model::Declarations::Type)
+      expect(schema.find('remark_procedure.remark_enumeration_item')).to be_instance_of(Expressir::Model::DataTypes::EnumerationItem)
+      expect(schema.find('remark_procedure.remark_constant')).to be_instance_of(Expressir::Model::Declarations::Constant)
+      expect(schema.find('remark_procedure.remark_variable')).to be_instance_of(Expressir::Model::Declarations::Variable)
+      expect(schema.find('remark_rule')).to be_instance_of(Expressir::Model::Declarations::Rule)
+      expect(schema.find('remark_rule.remark_type')).to be_instance_of(Expressir::Model::Declarations::Type)
+      expect(schema.find('remark_rule.remark_enumeration_item')).to be_instance_of(Expressir::Model::DataTypes::EnumerationItem)
+      expect(schema.find('remark_rule.remark_constant')).to be_instance_of(Expressir::Model::Declarations::Constant)
+      expect(schema.find('remark_rule.remark_variable')).to be_instance_of(Expressir::Model::Declarations::Variable)
+      expect(schema.find('remark_rule.WR1')).to be_instance_of(Expressir::Model::Declarations::WhereRule)
+      expect(schema.find('remark_rule.wr:WR1')).to be_instance_of(Expressir::Model::Declarations::WhereRule)
+      expect(schema.find('remark_rule.IP1')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
+      expect(schema.find('remark_rule.ip:IP1')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
+      expect(schema.find('remark_item')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
 
       # type scope
       type = schema.types.first
-      expect(type.find('WR1')).to be_instance_of(Expressir::Model::Where)
-      expect(type.find('wr:WR1')).to be_instance_of(Expressir::Model::Where)
-      expect(type.find('IP1')).to be_instance_of(Expressir::Model::RemarkItem)
-      expect(type.find('ip:IP1')).to be_instance_of(Expressir::Model::RemarkItem)
+      expect(type.find('WR1')).to be_instance_of(Expressir::Model::Declarations::WhereRule)
+      expect(type.find('wr:WR1')).to be_instance_of(Expressir::Model::Declarations::WhereRule)
+      expect(type.find('IP1')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
+      expect(type.find('ip:IP1')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
 
       # entity scope
       entity = schema.entities.first
-      expect(entity.find('remark_attribute')).to be_instance_of(Expressir::Model::Attribute)
-      expect(entity.find('remark_derived_attribute')).to be_instance_of(Expressir::Model::Attribute)
-      expect(entity.find('remark_inverse_attribute')).to be_instance_of(Expressir::Model::Attribute)
-      expect(entity.find('UR1')).to be_instance_of(Expressir::Model::Unique)
-      expect(entity.find('WR1')).to be_instance_of(Expressir::Model::Where)
-      expect(entity.find('wr:WR1')).to be_instance_of(Expressir::Model::Where)
-      expect(entity.find('IP1')).to be_instance_of(Expressir::Model::RemarkItem)
-      expect(entity.find('ip:IP1')).to be_instance_of(Expressir::Model::RemarkItem)
+      expect(entity.find('remark_attribute')).to be_instance_of(Expressir::Model::Declarations::Attribute)
+      expect(entity.find('remark_derived_attribute')).to be_instance_of(Expressir::Model::Declarations::Attribute)
+      expect(entity.find('remark_inverse_attribute')).to be_instance_of(Expressir::Model::Declarations::Attribute)
+      expect(entity.find('UR1')).to be_instance_of(Expressir::Model::Declarations::UniqueRule)
+      expect(entity.find('WR1')).to be_instance_of(Expressir::Model::Declarations::WhereRule)
+      expect(entity.find('wr:WR1')).to be_instance_of(Expressir::Model::Declarations::WhereRule)
+      expect(entity.find('IP1')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
+      expect(entity.find('ip:IP1')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
 
       # function scope
       function = schema.functions.first
-      expect(function.find('remark_parameter')).to be_instance_of(Expressir::Model::Parameter)
-      expect(function.find('remark_type')).to be_instance_of(Expressir::Model::Type)
-      expect(function.find('remark_enumeration_item')).to be_instance_of(Expressir::Model::EnumerationItem)
-      expect(function.find('remark_constant')).to be_instance_of(Expressir::Model::Constant)
-      expect(function.find('remark_variable')).to be_instance_of(Expressir::Model::Variable)
+      expect(function.find('remark_parameter')).to be_instance_of(Expressir::Model::Declarations::Parameter)
+      expect(function.find('remark_type')).to be_instance_of(Expressir::Model::Declarations::Type)
+      expect(function.find('remark_enumeration_item')).to be_instance_of(Expressir::Model::DataTypes::EnumerationItem)
+      expect(function.find('remark_constant')).to be_instance_of(Expressir::Model::Declarations::Constant)
+      expect(function.find('remark_variable')).to be_instance_of(Expressir::Model::Declarations::Variable)
 
       # procedure scope
       procedure = schema.procedures.first
-      expect(procedure.find('remark_parameter')).to be_instance_of(Expressir::Model::Parameter)
-      expect(procedure.find('remark_type')).to be_instance_of(Expressir::Model::Type)
-      expect(procedure.find('remark_enumeration_item')).to be_instance_of(Expressir::Model::EnumerationItem)
-      expect(procedure.find('remark_constant')).to be_instance_of(Expressir::Model::Constant)
-      expect(procedure.find('remark_variable')).to be_instance_of(Expressir::Model::Variable)
+      expect(procedure.find('remark_parameter')).to be_instance_of(Expressir::Model::Declarations::Parameter)
+      expect(procedure.find('remark_type')).to be_instance_of(Expressir::Model::Declarations::Type)
+      expect(procedure.find('remark_enumeration_item')).to be_instance_of(Expressir::Model::DataTypes::EnumerationItem)
+      expect(procedure.find('remark_constant')).to be_instance_of(Expressir::Model::Declarations::Constant)
+      expect(procedure.find('remark_variable')).to be_instance_of(Expressir::Model::Declarations::Variable)
 
       # rule scope
       rule = schema.rules.first
-      expect(rule.find('remark_type')).to be_instance_of(Expressir::Model::Type)
-      expect(rule.find('remark_enumeration_item')).to be_instance_of(Expressir::Model::EnumerationItem)
-      expect(rule.find('remark_constant')).to be_instance_of(Expressir::Model::Constant)
-      expect(rule.find('remark_variable')).to be_instance_of(Expressir::Model::Variable)
-      expect(rule.find('WR1')).to be_instance_of(Expressir::Model::Where)
-      expect(rule.find('wr:WR1')).to be_instance_of(Expressir::Model::Where)
-      expect(rule.find('IP1')).to be_instance_of(Expressir::Model::RemarkItem)
-      expect(rule.find('ip:IP1')).to be_instance_of(Expressir::Model::RemarkItem)
+      expect(rule.find('remark_type')).to be_instance_of(Expressir::Model::Declarations::Type)
+      expect(rule.find('remark_enumeration_item')).to be_instance_of(Expressir::Model::DataTypes::EnumerationItem)
+      expect(rule.find('remark_constant')).to be_instance_of(Expressir::Model::Declarations::Constant)
+      expect(rule.find('remark_variable')).to be_instance_of(Expressir::Model::Declarations::Variable)
+      expect(rule.find('WR1')).to be_instance_of(Expressir::Model::Declarations::WhereRule)
+      expect(rule.find('wr:WR1')).to be_instance_of(Expressir::Model::Declarations::WhereRule)
+      expect(rule.find('IP1')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
+      expect(rule.find('ip:IP1')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
 
       # retry search in parent scope
-      expect(entity.find('remark_type')).to be_instance_of(Expressir::Model::Type)
-      expect(entity.find('remark_type.WR1')).to be_instance_of(Expressir::Model::Where)
-      expect(entity.find('remark_type.wr:WR1')).to be_instance_of(Expressir::Model::Where)
-      expect(entity.find('remark_type.IP1')).to be_instance_of(Expressir::Model::RemarkItem)
-      expect(entity.find('remark_type.ip:IP1')).to be_instance_of(Expressir::Model::RemarkItem)
+      expect(entity.find('remark_type')).to be_instance_of(Expressir::Model::Declarations::Type)
+      expect(entity.find('remark_type.WR1')).to be_instance_of(Expressir::Model::Declarations::WhereRule)
+      expect(entity.find('remark_type.wr:WR1')).to be_instance_of(Expressir::Model::Declarations::WhereRule)
+      expect(entity.find('remark_type.IP1')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
+      expect(entity.find('remark_type.ip:IP1')).to be_instance_of(Expressir::Model::Declarations::RemarkItem)
     end
   end
 end