expressir 0.2.15 → 0.2.21

data/original/examples/syntax/syntax_schema_head_formatted.exp

@@ -0,0 +1,18 @@
+SCHEMA syntax_schema 'version';
+
+USE FROM contract_schema;
+USE FROM contract_schema
+  (contract);
+USE FROM contract_schema
+  (contract,
+   contract2);
+USE FROM contract_schema
+  (contract AS contract2);
+REFERENCE FROM contract_schema;
+REFERENCE FROM contract_schema
+  (contract);
+REFERENCE FROM contract_schema
+  (contract,
+   contract2);
+REFERENCE FROM contract_schema
+  (contract AS contract2);

data/spec/expressir/express_exp/cache_spec.rb

@@ -0,0 +1,64 @@
+require "yaml"
+require "tempfile"
+require "spec_helper"
+require "expressir/express_exp/parser"
+require "expressir/express_exp/cache"
+
+RSpec.describe Expressir::ExpressExp::Cache do
+  TEST_VERSION = "0.0.0"
+
+  describe ".to_file" do
+    it "exports an object" do
+      temp_file = Tempfile.new
+
+      repository = Expressir::Model::Repository.new
+
+      begin
+        Expressir::ExpressExp::Cache.to_file(temp_file, repository, test_overwrite_version: TEST_VERSION)
+
+        size = File.size(temp_file)
+
+        expect(size).to be > 0
+      ensure
+        temp_file.close
+        temp_file.unlink
+      end
+    end
+  end
+
+  describe ".from_file" do
+    it "parses a file" do
+      temp_file = Tempfile.new
+
+      repository = Expressir::Model::Repository.new
+
+      begin
+        Expressir::ExpressExp::Cache.to_file(temp_file, repository, test_overwrite_version: TEST_VERSION)
+
+        result = Expressir::ExpressExp::Cache.from_file(temp_file, test_overwrite_version: TEST_VERSION)
+
+        expect(result).to be_instance_of(Expressir::Model::Repository)
+      ensure
+        temp_file.close
+        temp_file.unlink
+      end
+    end
+
+    it "fails parsing a file from a different Expressir version" do
+      temp_file = Tempfile.new
+
+      repository = Expressir::Model::Repository.new
+
+      begin
+        Expressir::ExpressExp::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)
+      ensure
+        temp_file.close
+        temp_file.unlink
+      end
+    end
+  end
+end

data/spec/expressir/express_exp/formatter_spec.rb

@@ -0,0 +1,111 @@
+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 (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

data/spec/expressir/express_exp/parser_spec.rb

@@ -0,0 +1,98 @@
+require "yaml"
+require "spec_helper"
+require "expressir/express_exp/parser"
+
+RSpec.describe Expressir::ExpressExp::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")
+
+      repo = Expressir::ExpressExp::Parser.from_file(exp_file)
+      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path, skip_empty: true))
+      # File.write(yaml_file, result)
+      expected_result = File.read(yaml_file)
+      
+      expect(result).to eq(expected_result)
+    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")
+
+      repo = Expressir::ExpressExp::Parser.from_file(exp_file)
+      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path, skip_empty: true))
+      # File.write(yaml_file, result)
+      expected_result = File.read(yaml_file)
+      
+      expect(result).to eq(expected_result)
+    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")
+
+      repo = Expressir::ExpressExp::Parser.from_file(exp_file)
+      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path, skip_empty: true))
+      # File.write(yaml_file, result)
+      expected_result = File.read(yaml_file)
+      
+      expect(result).to eq(expected_result)
+    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")
+
+      repo = Expressir::ExpressExp::Parser.from_file(exp_file)
+      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path, skip_empty: true))
+      # File.write(yaml_file, result)
+      expected_result = File.read(yaml_file)
+      
+      expect(result).to eq(expected_result)
+    end
+
+    it "parses a file including original source (multiple.exp)" do
+      exp_file = Expressir.root_path.join("original", "examples", "syntax", "multiple.exp")
+
+      input = File.read(exp_file)
+      repo = Expressir::ExpressExp::Parser.from_file(exp_file, include_source: true)
+
+      schema = repo.schemas.first
+      start_index = input.index("SCHEMA")
+      stop_index = input.index("END_SCHEMA;") + "END_SCHEMA;".length - 1
+      expected_result = input[start_index..stop_index]
+      expect(schema.source).to eq(expected_result)
+
+      entity = schema.entities.first
+      start_index = input.index("ENTITY")
+      stop_index = input.index("END_ENTITY;") + "END_ENTITY;".length - 1
+      expected_result = input[start_index..stop_index]
+      expect(entity.source).to eq(expected_result)
+    end
+  end
+
+  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")
+      ]
+
+      repo = Expressir::ExpressExp::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[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)
+      expect(schemas[3].id).to eq("multiple_schema3")
+      expect(schemas[4].file).to eq(exp_files[1].to_s)
+      expect(schemas[4].id).to eq("multiple_schema4")
+    end
+  end
+end

data/spec/expressir/model/{model_element/find_spec.rb → model_element_spec.rb}

@@ -1,10 +1,80 @@
+
+require "yaml"
 require "spec_helper"
 require "expressir/express_exp/parser"
+require "expressir/express_exp/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")
+
+      repo = Expressir::ExpressExp::Parser.from_file(exp_file)
+
+      result = YAML.dump(repo.to_hash(root_path: Expressir.root_path, formatter: Expressir::ExpressExp::Formatter, skip_empty: true))
+      # File.write(yaml_file, result)
+      expected_result = File.read(yaml_file)
+      
+      expect(result).to eq(expected_result)
+    end
+  end
+
+  describe ".from_hash" do
+    it "parses an object (single.yaml)" do
+      yaml_file = Expressir.root_path.join("original", "examples", "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))
+      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")
+
+      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))
+      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")
+
+      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))
+      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")
+
+      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))
+      expected_result = File.read(yaml_file)
+
+      expect(result).to eq(expected_result)
+    end
+  end
+
   describe ".find" do
     it "finds an object" do
-      repo = Expressir::ExpressExp::Parser.from_file(sample_file)
+      exp_file = Expressir.root_path.join("original", "examples", "syntax", "remark.exp")
+
+      repo = Expressir::ExpressExp::Parser.from_file(exp_file)
 
       # universal scope
       expect(repo.find('remark_schema')).to be_instance_of(Expressir::Model::Schema)
@@ -12,14 +82,18 @@ RSpec.describe Expressir::Model::ModelElement do
       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::InformalProposition)
+      expect(repo.find('remark_schema.remark_type.ip:IP1')).to be_instance_of(Expressir::Model::InformalProposition)
       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.remark_unique')).to be_instance_of(Expressir::Model::Unique)
+      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::InformalProposition)
+      expect(repo.find('remark_schema.remark_entity.ip:IP1')).to be_instance_of(Expressir::Model::InformalProposition)
       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)
@@ -40,19 +114,27 @@ RSpec.describe Expressir::Model::ModelElement do
       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::InformalProposition)
+      expect(repo.find('remark_schema.remark_rule.ip:IP1')).to be_instance_of(Expressir::Model::InformalProposition)
 
       # 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::InformalProposition)
+      expect(schema.find('remark_type.ip:IP1')).to be_instance_of(Expressir::Model::InformalProposition)
       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.remark_unique')).to be_instance_of(Expressir::Model::Unique)
+      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::InformalProposition)
+      expect(schema.find('remark_entity.ip:IP1')).to be_instance_of(Expressir::Model::InformalProposition)
       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)
@@ -73,20 +155,26 @@ RSpec.describe Expressir::Model::ModelElement do
       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::InformalProposition)
+      expect(schema.find('remark_rule.ip:IP1')).to be_instance_of(Expressir::Model::InformalProposition)
 
       # 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::InformalProposition)
+      expect(type.find('ip:IP1')).to be_instance_of(Expressir::Model::InformalProposition)
 
       # 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('remark_unique')).to be_instance_of(Expressir::Model::Unique)
+      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::InformalProposition)
+      expect(entity.find('ip:IP1')).to be_instance_of(Expressir::Model::InformalProposition)
 
       # function scope
       function = schema.functions.first
@@ -112,17 +200,15 @@ RSpec.describe Expressir::Model::ModelElement do
       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::InformalProposition)
+      expect(rule.find('ip:IP1')).to be_instance_of(Expressir::Model::InformalProposition)
 
       # 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::InformalProposition)
+      expect(entity.find('remark_type.ip:IP1')).to be_instance_of(Expressir::Model::InformalProposition)
     end
   end
-
-  def sample_file
-    @sample_file ||= Expressir.root_path.join(
-      "original", "examples", "syntax", "remark.exp"
-    )
-  end
 end