Make "IS" type default

lib/pubid/iso/identifier.rb

@@ -71,23 +71,23 @@ def initialize(publisher: "ISO", number: nil, stage: nil, iteration: nil, supple
                          TypedStage.new
                        end
 
-        if @typed_stage.type == :is && iteration
-          raise Errors::IsStageIterationError, "IS stage document cannot have iteration"
-        end
-
         if stage
-          provided_type = @typed_stage.type
-
           @typed_stage.parse_stage(stage.is_a?(Parslet::Slice) ? stage.to_s : stage)
-          if !provided_type.nil? && @typed_stage.type != provided_type
+          if type && @typed_stage.type != type
             raise Errors::StageInvalidError,
-                  "cannot assign typed stage for document with different type (#{provided_type} vs #{@typed_stage.type})"
+                  "cannot assign typed stage for document with different type (#{type} vs #{@typed_stage.type})"
           end
+        elsif @typed_stage.type == :is && iteration
+          raise Errors::IsStageIterationError, "IS stage document cannot have iteration"
         end
+
       elsif iteration
         raise Errors::IterationWithoutStageError, "Document without stage cannot have iteration"
       end
 
+      # Assign typed stage to apply default type
+      @typed_stage = TypedStage.new unless @typed_stage
+
       @iteration = iteration.to_i if iteration
       @supplement = supplement if supplement
       @joint_document = joint_document if joint_document

lib/pubid/iso/type.rb

@@ -49,7 +49,7 @@ class Type
 
     # Create new type
     # @param type [Symbol]
-    def initialize(type)
+    def initialize(type = :is)
       raise Errors::WrongTypeError, "#{type} type is not available" unless TYPE_NAMES.key?(type)
 
       @type = type

lib/pubid/iso/typed_stage.rb

@@ -74,13 +74,17 @@ class TypedStage
     # @param type [Symbol,Type] eg. :tr, Type.new(:tr)
     # @param stage [Symbol,Stage] eg. :CD, Stage.new(abbr: :CD)
     def initialize(abbr: nil, type: nil, stage: nil)
-      @type = type.is_a?(Type) ? type : Type.new(type) if type
+      @type = if type
+                type.is_a?(Type) ? type : Type.new(type)
+              else
+                Type.new
+              end
       @stage = stage.is_a?(Stage) ? stage : Stage.new(abbr: stage) if stage
 
       if abbr
         raise Errors::TypeStageInvalidError, "#{abbr} is not valid typed stage" unless TYPED_STAGES.key?(abbr)
         assign_abbreviation(abbr)
-      elsif [email protected]?
+      elsif [email protected]? && [email protected]
         # lookup for typed stage
         @typed_stage = lookup_typed_stage
       end
@@ -186,7 +190,7 @@ def parse_stage(stage_or_typed_stage)
       else
         raise Errors::TypeStageParseError, "cannot parse typed stage or stage"
       end
-      @typed_stage = lookup_typed_stage
+      @typed_stage = lookup_typed_stage unless @stage&.abbr
     end
 
     # Parse stage or typed stage

spec/pubid_iso/identifier/create_new_identifier_spec.rb

@@ -12,6 +12,10 @@ module Pubid::Iso
         expect(subject.to_s).to eq("ISO #{number}")
       end
 
+      it "assigns default type" do
+        expect(subject.type).to eq(:is)
+      end
+
       context "when have joint document" do
         let(:params) { { joint_document: "IDF #{number}" } }
 

spec/pubid_iso/identifier/identifier_spec.rb

@@ -604,6 +604,10 @@ module Pubid::Iso
 
       it_behaves_like "converts pubid to pubid"
       it_behaves_like "converts pubid to urn"
+
+      it "has assigned IS type" do
+        expect(subject.type).to eq(:is)
+      end
     end
 
     context "ISO/TS 19115-3:2016" do

spec/pubid_iso/type_spec.rb

@@ -1,5 +1,13 @@
 module Pubid::Iso
   RSpec.describe Type do
+    context "when don't have type" do
+      subject { described_class.new }
+
+      it "assigns IS type by default" do
+        expect(subject.type).to eq(:is)
+      end
+    end
+
     context "when using symbol" do
       subject { described_class.new(type) }
       let(:type) { :tr }

spec/pubid_iso/typed_stage_spec.rb

@@ -5,6 +5,10 @@ module Pubid::Iso
     let(:type) { nil }
     let(:stage) { nil }
 
+    it "assigns type by default" do
+      expect(subject.type).to be_a(Type)
+    end
+
     describe "#has_typed_stage?" do
       subject { described_class.has_typed_stage?(typed_stage) }