expressir 0.2.26-x86_64-linux → 1.2.0-x86_64-linux

data/lib/expressir/model/statements/alias.rb

@@ -1,24 +1,28 @@
 module Expressir
   module Model
     module Statements
-      class Alias < ModelElement
+      # Specified in ISO 10303-11:2004
+      # - section 13.2 Alias statement
+      class Alias < Statement
         include Identifier
 
-        model_attr_accessor :expression
-        model_attr_accessor :statements
+        model_attr_accessor :expression, 'Expression'
+        model_attr_accessor :statements, 'Array<Statement>'
 
+        # @param [Hash] options
+        # @option (see Identifier#initialize_identifier)
+        # @option options [Expression] :expression
+        # @option options [Array<Statement>] :statements
         def initialize(options = {})
-          @id = options[:id]
-          @remarks = options.fetch(:remarks, [])
-          @remark_items = options.fetch(:remark_items, [])
-          @source = options[:source]
+          initialize_identifier(options)
 
           @expression = options[:expression]
-          @statements = options.fetch(:statements, [])
+          @statements = options[:statements] || []
 
           super
         end
 
+        # @return [Array<Declaration>]
         def children
           [
             self,

data/lib/expressir/model/statements/assignment.rb

@@ -1,10 +1,15 @@
 module Expressir
   module Model
     module Statements
-      class Assignment < ModelElement
-        model_attr_accessor :ref
-        model_attr_accessor :expression
+      # Specified in ISO 10303-11:2004
+      # - section 13.3 Assignment
+      class Assignment < Statement
+        model_attr_accessor :ref, 'Reference'
+        model_attr_accessor :expression, 'Expression'
 
+        # @param [Hash] options
+        # @option options [Reference] :ref
+        # @option options [Expression] :expression
         def initialize(options = {})
           @ref = options[:ref]
           @expression = options[:expression]

data/lib/expressir/model/statements/case.rb

@@ -1,14 +1,20 @@
 module Expressir
   module Model
     module Statements
-      class Case < ModelElement
-        model_attr_accessor :expression
-        model_attr_accessor :actions
-        model_attr_accessor :otherwise_statement
+      # Specified in ISO 10303-11:2004
+      # - section 13.4 Case statement
+      class Case < Statement
+        model_attr_accessor :expression, 'Expression'
+        model_attr_accessor :actions, 'Array<CaseAction>'
+        model_attr_accessor :otherwise_statement, 'Statement'
 
+        # @param [Hash] options
+        # @option options [Expression] :expression
+        # @option options [Array<CaseAction>] :statements
+        # @option options [Statement] :otherwise_statement
         def initialize(options = {})
           @expression = options[:expression]
-          @actions = options.fetch(:actions, [])
+          @actions = options[:actions] || []
           @otherwise_statement = options[:otherwise_statement]
 
           super

data/lib/expressir/model/statements/case_action.rb

@@ -1,12 +1,17 @@
 module Expressir
   module Model
     module Statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.4 Case statement
       class CaseAction < ModelElement
-        model_attr_accessor :labels
-        model_attr_accessor :statement
+        model_attr_accessor :labels, 'Array<Expression>'
+        model_attr_accessor :statement, 'Statement'
 
+        # @param [Hash] options
+        # @option options [Array<Expression>] :labels
+        # @option options [Statement] :statement
         def initialize(options = {})
-          @labels = options.fetch(:labels, [])
+          @labels = options[:labels] || []
           @statement = options[:statement]
 
           super

data/lib/expressir/model/statements/compound.rb

@@ -1,11 +1,15 @@
 module Expressir
   module Model
     module Statements
-      class Compound < ModelElement
-        model_attr_accessor :statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.5 Compound statement
+      class Compound < Statement
+        model_attr_accessor :statements, 'Array<Statement>'
 
+        # @param [Hash] options
+        # @option options [Array<Statement>] :statements
         def initialize(options = {})
-          @statements = options.fetch(:statements, [])
+          @statements = options[:statements] || []
 
           super
         end

data/lib/expressir/model/statements/escape.rb

@@ -1,7 +1,9 @@
 module Expressir
   module Model
     module Statements
-      class Escape < ModelElement
+      # Specified in ISO 10303-11:2004
+      # - section 13.6 Escape statement
+      class Escape < Statement
       end
     end
   end

data/lib/expressir/model/statements/if.rb

@@ -1,15 +1,21 @@
 module Expressir
   module Model
     module Statements
-      class If < ModelElement
-        model_attr_accessor :expression
-        model_attr_accessor :statements
-        model_attr_accessor :else_statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.7 If ... Then ... Else statement
+      class If < Statement
+        model_attr_accessor :expression, 'Expression'
+        model_attr_accessor :statements, 'Array<Statement>'
+        model_attr_accessor :else_statements, 'Array<Statement>'
 
+        # @param [Hash] options
+        # @option options [Expression] :expression
+        # @option options [Array<Statement>] :statements
+        # @option options [Array<Statement>] :else_statements
         def initialize(options = {})
           @expression = options[:expression]
-          @statements = options.fetch(:statements, [])
-          @else_statements = options.fetch(:else_statements, [])
+          @statements = options[:statements] || []
+          @else_statements = options[:else_statements] || []
 
           super
         end

data/lib/expressir/model/statements/null.rb

@@ -1,7 +1,9 @@
 module Expressir
   module Model
     module Statements
-      class Null < ModelElement
+      # Specified in ISO 10303-11:2004
+      # - section 13.1 Null (statement)
+      class Null < Statement
       end
     end
   end

data/lib/expressir/model/statements/procedure_call.rb

@@ -0,0 +1,22 @@
+module Expressir
+  module Model
+    module Statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.8 Procedure call statement
+      class ProcedureCall < Statement
+        model_attr_accessor :procedure, 'Reference'
+        model_attr_accessor :parameters, 'Array<Expression>'
+
+        # @param [Hash] options
+        # @option options [Reference] :procedure
+        # @option options [Array<Expression>] :parameters
+        def initialize(options = {})
+          @procedure = options[:procedure]
+          @parameters = options[:parameters] || []
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/statements/repeat.rb

@@ -1,32 +1,40 @@
 module Expressir
   module Model
     module Statements
-      class Repeat < ModelElement
+      # Specified in ISO 10303-11:2004
+      # - section 13.9 Repeat statement
+      class Repeat < Statement
         include Identifier
 
-        model_attr_accessor :bound1
-        model_attr_accessor :bound2
-        model_attr_accessor :increment
-        model_attr_accessor :while_expression
-        model_attr_accessor :until_expression
-        model_attr_accessor :statements
+        model_attr_accessor :bound1, 'Expression'
+        model_attr_accessor :bound2, 'Expression'
+        model_attr_accessor :increment, 'Expression'
+        model_attr_accessor :while_expression, 'Expression'
+        model_attr_accessor :until_expression, 'Expression'
+        model_attr_accessor :statements, 'Array<Statement>'
 
+        # @param [Hash] options
+        # @option (see Identifier#initialize_identifier)
+        # @option options [Expression] :bound1
+        # @option options [Expression] :bound2
+        # @option options [Expression] :increment
+        # @option options [Expression] :while_expression
+        # @option options [Expression] :until_expression
+        # @option options [Array<Statement>] :statements
         def initialize(options = {})
-          @id = options[:id]
-          @remarks = options.fetch(:remarks, [])
-          @remark_items = options.fetch(:remark_items, [])
-          @source = options[:source]
+          initialize_identifier(options)
 
           @bound1 = options[:bound1]
           @bound2 = options[:bound2]
           @increment = options[:increment]
           @while_expression = options[:while_expression]
           @until_expression = options[:until_expression]
-          @statements = options.fetch(:statements, [])
+          @statements = options[:statements] || []
 
           super
         end
 
+        # @return [Array<Declaration>]
         def children
           [
             self,

data/lib/expressir/model/statements/return.rb

@@ -1,9 +1,13 @@
 module Expressir
   module Model
     module Statements
-      class Return < ModelElement
-        model_attr_accessor :expression
+      # Specified in ISO 10303-11:2004
+      # - section 13.10 Return statement
+      class Return < Statement
+        model_attr_accessor :expression, 'Expression'
 
+        # @param [Hash] options
+        # @option options [Expression] :expression
         def initialize(options = {})
           @expression = options[:expression]
 

data/lib/expressir/model/statements/skip.rb

@@ -1,7 +1,9 @@
 module Expressir
   module Model
     module Statements
-      class Skip < ModelElement
+      # Specified in ISO 10303-11:2004
+      # - section 13.11 Skip statement
+      class Skip < Statement
       end
     end
   end

data/lib/expressir/model/supertype_expression.rb

@@ -0,0 +1,9 @@
+module Expressir
+  module Model
+    # Specified in ISO 10303-11:2004
+    # - section 9.2.5 Subtype/supertype constraints
+    # @abstract
+    class SupertypeExpression < ModelElement
+    end
+  end
+end

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/model.rb

@@ -1,70 +1,79 @@
 require 'expressir/model/model_element'
 
 require 'expressir/model/cache'
-
+require 'expressir/model/data_type'
+require 'expressir/model/declaration'
+require 'expressir/model/expression'
 require 'expressir/model/identifier'
-
-require 'expressir/model/attribute'
-require 'expressir/model/constant'
-require 'expressir/model/entity'
-require 'expressir/model/enumeration_item'
-require 'expressir/model/function'
-require 'expressir/model/interface'
-require 'expressir/model/interface_item'
-require 'expressir/model/interfaced_item'
-require 'expressir/model/parameter'
-require 'expressir/model/procedure'
-require 'expressir/model/remark_item'
+require 'expressir/model/literal'
+require 'expressir/model/reference'
 require 'expressir/model/repository'
-require 'expressir/model/rule'
-require 'expressir/model/schema'
-require 'expressir/model/subtype_constraint'
-require 'expressir/model/type'
-require 'expressir/model/unique'
-require 'expressir/model/variable'
-require 'expressir/model/where'
+require 'expressir/model/statement'
+require 'expressir/model/supertype_expression'
+require 'expressir/model/data_types/aggregate'
+require 'expressir/model/data_types/array'
+require 'expressir/model/data_types/bag'
+require 'expressir/model/data_types/binary'
+require 'expressir/model/data_types/boolean'
+require 'expressir/model/data_types/enumeration'
+require 'expressir/model/data_types/enumeration_item'
+require 'expressir/model/data_types/generic_entity'
+require 'expressir/model/data_types/generic'
+require 'expressir/model/data_types/integer'
+require 'expressir/model/data_types/list'
+require 'expressir/model/data_types/logical'
+require 'expressir/model/data_types/number'
+require 'expressir/model/data_types/real'
+require 'expressir/model/data_types/set'
+require 'expressir/model/data_types/select'
+require 'expressir/model/data_types/string'
+require 'expressir/model/declarations/attribute'
+require 'expressir/model/declarations/constant'
+require 'expressir/model/declarations/entity'
+require 'expressir/model/declarations/function'
+require 'expressir/model/declarations/interface'
+require 'expressir/model/declarations/interface_item'
+require 'expressir/model/declarations/interfaced_item'
+require 'expressir/model/declarations/parameter'
+require 'expressir/model/declarations/procedure'
+require 'expressir/model/declarations/remark_item'
+require 'expressir/model/declarations/rule'
+require 'expressir/model/declarations/schema'
+require 'expressir/model/declarations/schema_version'
+require 'expressir/model/declarations/schema_version_item'
+require 'expressir/model/declarations/subtype_constraint'
+require 'expressir/model/declarations/type'
+require 'expressir/model/declarations/unique_rule'
+require 'expressir/model/declarations/variable'
+require 'expressir/model/declarations/where_rule'
 require 'expressir/model/expressions/aggregate_initializer'
-require 'expressir/model/expressions/aggregate_item'
+require 'expressir/model/expressions/aggregate_initializer_item'
 require 'expressir/model/expressions/binary_expression'
-require 'expressir/model/expressions/call'
-require 'expressir/model/expressions/attribute_reference'
 require 'expressir/model/expressions/entity_constructor'
-require 'expressir/model/expressions/group_reference'
-require 'expressir/model/expressions/index_reference'
+require 'expressir/model/expressions/function_call'
 require 'expressir/model/expressions/interval'
 require 'expressir/model/expressions/query_expression'
-require 'expressir/model/expressions/simple_reference'
 require 'expressir/model/expressions/unary_expression'
 require 'expressir/model/literals/binary'
 require 'expressir/model/literals/integer'
 require 'expressir/model/literals/logical'
 require 'expressir/model/literals/real'
 require 'expressir/model/literals/string'
+require 'expressir/model/references/attribute_reference'
+require 'expressir/model/references/group_reference'
+require 'expressir/model/references/index_reference'
+require 'expressir/model/references/simple_reference'
 require 'expressir/model/statements/alias'
 require 'expressir/model/statements/assignment'
-require 'expressir/model/statements/call'
 require 'expressir/model/statements/case'
 require 'expressir/model/statements/case_action'
 require 'expressir/model/statements/compound'
 require 'expressir/model/statements/escape'
 require 'expressir/model/statements/if'
 require 'expressir/model/statements/null'
+require 'expressir/model/statements/procedure_call'
 require 'expressir/model/statements/repeat'
 require 'expressir/model/statements/return'
 require 'expressir/model/statements/skip'
-require 'expressir/model/types/aggregate'
-require 'expressir/model/types/array'
-require 'expressir/model/types/bag'
-require 'expressir/model/types/binary'
-require 'expressir/model/types/boolean'
-require 'expressir/model/types/enumeration'
-require 'expressir/model/types/generic_entity'
-require 'expressir/model/types/generic'
-require 'expressir/model/types/integer'
-require 'expressir/model/types/list'
-require 'expressir/model/types/logical'
-require 'expressir/model/types/number'
-require 'expressir/model/types/real'
-require 'expressir/model/types/set'
-require 'expressir/model/types/select'
-require 'expressir/model/types/string'
+require 'expressir/model/supertype_expressions/binary_supertype_expression'
+require 'expressir/model/supertype_expressions/oneof_supertype_expression'

data/lib/expressir/version.rb

@@ -1,3 +1,3 @@
 module Expressir
-  VERSION = "0.2.26".freeze
+  VERSION = "1.2.0".freeze
 end

data/lib/expressir.rb

@@ -2,7 +2,6 @@ require "expressir/version"
 
 require "expressir/cli"
 require "expressir/config"
-require "expressir/express"
 
 module Expressir
   class Error < StandardError; 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