Conclusion.js ➔ Conclusion - Code Metrics - Inspection of "Objects being copied when building with instances" - rootsdev/gedcomx-js - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#13)

by Justin

created 2016-06-06 17:54 UTC

Conclusion.js ➔ Conclusion B

↳ Parent: src/Conclusion.js

Complexity

Conditions	4
Paths	4

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	4
c	1
b	0
f	0
nc	4
nop	1
dl	0
loc	23
rs	8.7972

var ExtensibleData = require('./ExtensibleData'),
    Attribution = require('./Attribution'),
    ResourceReference = require('./ResourceReference'),
    Note = require('./Note'),
    SourceReference = require('./SourceReference'),
    utils = require('./utils');

/**
 * An abstract concept for a basic genealogical data item.
 * 
 * @constructor
 * @param {Object} [json]

 */
var Conclusion = function(json){
  
  // Protect against forgetting the new keyword when calling the constructor
  if(!(this instanceof Conclusion)){
    return new Conclusion(json);
  }
  
  // If the given object is already an instance then just return it. DON'T copy it.
  if(Conclusion.isInstance(json)){
    return json;
  }
  
  ExtensibleData.call(this, json);
  
  if(json){
function isBig(a) {
    if (a > 5000) {
        return "yes";
    }
}

console.log(isBig(5001)); //returns yes
console.log(isBig(42)); //returns undefined
    this.setAttribution(json.attribution);
    this.setAnalysis(json.analysis);
    this.setConfidence(json.confidence);
    this.setLang(json.lang);
    this.setNotes(json.notes);
    this.setSources(json.sources);

  }
};

Conclusion.prototype = Object.create(ExtensibleData.prototype);

Conclusion._gedxClass = Conclusion.prototype._gedxClass = 'GedcomX.Conclusion';

/**
 * Check whether the given object is an instance of this class.
 * 
 * @param {Object} obj
 * @returns {Boolean}
 */
Conclusion.isInstance = function(obj){
  return utils.isInstance(obj, this._gedxClass);
};

/**
 * Get the attribution.
 * 
 * @returns {Attribution}
 */
Conclusion.prototype.getAttribution = function(){
  return this.attribution;
};

/**
 * Set the attribution
 * 
 * @param {Object|Attribution} attribution
 * @returns {Conclusion} This instance
 */
Conclusion.prototype.setAttribution = function(attribution){
  if(attribution){
    this.attribution = new Attribution(attribution);
  }
  return this;
};

/**
 * Get analysis.
 * 
 * @returns {ResourceReference} analysis
 */
Conclusion.prototype.getAnalysis = function(){
  return this.analysis;
};

/**
 * Set the analysis
 * 
 * @param {Object|ResourceReference} analysis
 * @returns {Conclusion} This instance
 */
Conclusion.prototype.setAnalysis = function(analysis){
  if(analysis){
    this.analysis = new ResourceReference(analysis);
  }
  return this;
};

/**
 * Get the confidence.
 * 
 * @returns {String} confidence
 */
Conclusion.prototype.getConfidence = function(){
  return this.confidence;
};

/**
 * Set the confidence.
 * 
 * @param {String} confidence
 * @returns {Conclusion} This instance
 */
Conclusion.prototype.setConfidence = function(confidence){
  this.confidence = confidence;
  return this;
};

/**
 * Get the language identifier.
 * 
 * @returns {String} lang
 */
Conclusion.prototype.getLang = function(){
  return this.lang;
};

/**
 * Set the language identifier.
 * 
 * @param {String} lang
 * @returns {Conclusion} This instance.
 */
Conclusion.prototype.setLang = function(lang){
  this.lang = lang;
  return this;
};

/**
 * Get the notes
 * 
 * @returns {Note[]} notes
 */
Conclusion.prototype.getNotes = function(){
  return this.notes || [];
};

/**
 * Set the notes
 * 
 * @param {Object[]|Note[]} notes
 * @returns {Conclusion} This instance
 */
Conclusion.prototype.setNotes = function(notes){
  if(notes){
    var conclusion = this;
    conclusion.notes = [];
    notes.forEach(function(note){
      conclusion.addNote(note);
    });
  }
  return this;
};

/**
 * Add a note
 * 
 * @param {Object|Note} note
 * @returns {Conclusion} This instance
 */
Conclusion.prototype.addNote = function(note){
  if(note){
    if(!Array.isArray(this.notes)){
      this.notes = [];
    }
    this.notes.push(new Note(note));
  }
  return this;
};

/**
 * Get the sources
 * 
 * @returns {SourceReference[]}
 */
Conclusion.prototype.getSources = function(){
  return this.sources || [];
};

/**
 * Set the sources
 * 
 * @param {Object[]|SourceReference[]} sources
 * @returns {Conclusion} This instance
 */
Conclusion.prototype.setSources = function(sources){
  if(sources){
    var conclusion = this;
    conclusion.sources = [];
    sources.forEach(function(source){
      conclusion.addSource(source);
    });
  }
  return this;
};

/**
 * Add a source
 * 
 * @param {SourceReference} source
 * @returns {Conclusion} This instance
 */
Conclusion.prototype.addSource = function(source){
  if(source){
    if(!Array.isArray(this.sources)){
      this.sources = [];
    }
    this.sources.push(new SourceReference(source));
  }
  return this;
};

/**
 * Export the object as JSON
 * 
 * @return {Object} JSON object
 */
Conclusion.prototype.toJSON = function(){
  var json = ExtensibleData.prototype.toJSON.call(this);
  
  if(this.lang){
    json.lang = this.lang;
  }
  
  if(this.confidence){
    json.confidence = this.confidence;
  }
  
  if(this.analysis){
    json.analysis = this.analysis.toJSON();
  }
  
  if(this.attribution){
    json.attribution = this.attribution.toJSON();
  }
  
  if(this.sources){
    json.sources = this.sources.map(function(source){
      return source.toJSON();
    });
  }
  
  if(this.notes){
    json.notes = this.notes.map(function(note){
      return note.toJSON();
    });
  }
  
  return json;
};

module.exports = Conclusion;

1			var ExtensibleData = require('./ExtensibleData'),
2			Attribution = require('./Attribution'),
3			ResourceReference = require('./ResourceReference'),
4			Note = require('./Note'),
5			SourceReference = require('./SourceReference'),
6			utils = require('./utils');
7
8			/**
9			* An abstract concept for a basic genealogical data item.
10			*
11			* @constructor
12			* @param {Object} [json]
			0 ignored issues – show Documentation introduced 2016-05-27 14:53 UTC by Report Bug Copy Issue Report The parameter `[json]` does not exist. Did you maybe forget to remove this comment? Loading history...
13			*/
14			var Conclusion = function(json){
15
16			// Protect against forgetting the new keyword when calling the constructor
17			if(!(this instanceof Conclusion)){
18			return new Conclusion(json);
19			}
20
21			// If the given object is already an instance then just return it. DON'T copy it.
22			if(Conclusion.isInstance(json)){
23			return json;
24			}
25
26			ExtensibleData.call(this, json);
27
28			if(json){
			0 ignored issues – show Complexity Best Practice introduced 2016-05-27 14:53 UTC by Report Bug Copy Issue Report There is no return statement if `json` is `false`. Are you sure this is correct? If so, consider adding `return;` explicitly. This check looks for functions where a `return` statement is found in some execution paths, but not in all. Consider this little piece of code function isBig(a) { if (a > 5000) { return "yes"; } } console.log(isBig(5001)); //returns yes console.log(isBig(42)); //returns undefined The function `isBig` will only return a specific value when its parameter is bigger than 5000. In any other case, it will implicitly return `undefined`. This behaviour may not be what you had intended. In any case, you can add a `return undefined` to the other execution path to make the return value explicit. Loading history...
29			this.setAttribution(json.attribution);
30			this.setAnalysis(json.analysis);
31			this.setConfidence(json.confidence);
32			this.setLang(json.lang);
33			this.setNotes(json.notes);
34			this.setSources(json.sources);
			0 ignored issues – show Best Practice introduced 2016-05-27 14:53 UTC by Report Bug Copy Issue Report There is no `return` statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding `return undefined;` explicitly. Loading history...
35			}
36			};
37
38			Conclusion.prototype = Object.create(ExtensibleData.prototype);
39
40			Conclusion._gedxClass = Conclusion.prototype._gedxClass = 'GedcomX.Conclusion';
41
42			/**
43			* Check whether the given object is an instance of this class.
44			*
45			* @param {Object} obj
46			* @returns {Boolean}
47			*/
48			Conclusion.isInstance = function(obj){
49			return utils.isInstance(obj, this._gedxClass);
50			};
51
52			/**
53			* Get the attribution.
54			*
55			* @returns {Attribution}
56			*/
57			Conclusion.prototype.getAttribution = function(){
58			return this.attribution;
59			};
60
61			/**
62			* Set the attribution
63			*
64			* @param {Object\|Attribution} attribution
65			* @returns {Conclusion} This instance
66			*/
67			Conclusion.prototype.setAttribution = function(attribution){
68			if(attribution){
69			this.attribution = new Attribution(attribution);
70			}
71			return this;
72			};
73
74			/**
75			* Get analysis.
76			*
77			* @returns {ResourceReference} analysis
78			*/
79			Conclusion.prototype.getAnalysis = function(){
80			return this.analysis;
81			};
82
83			/**
84			* Set the analysis
85			*
86			* @param {Object\|ResourceReference} analysis
87			* @returns {Conclusion} This instance
88			*/
89			Conclusion.prototype.setAnalysis = function(analysis){
90			if(analysis){
91			this.analysis = new ResourceReference(analysis);
92			}
93			return this;
94			};
95
96			/**
97			* Get the confidence.
98			*
99			* @returns {String} confidence
100			*/
101			Conclusion.prototype.getConfidence = function(){
102			return this.confidence;
103			};
104
105			/**
106			* Set the confidence.
107			*
108			* @param {String} confidence
109			* @returns {Conclusion} This instance
110			*/
111			Conclusion.prototype.setConfidence = function(confidence){
112			this.confidence = confidence;
113			return this;
114			};
115
116			/**
117			* Get the language identifier.
118			*
119			* @returns {String} lang
120			*/
121			Conclusion.prototype.getLang = function(){
122			return this.lang;
123			};
124
125			/**
126			* Set the language identifier.
127			*
128			* @param {String} lang
129			* @returns {Conclusion} This instance.
130			*/
131			Conclusion.prototype.setLang = function(lang){
132			this.lang = lang;
133			return this;
134			};
135
136			/**
137			* Get the notes
138			*
139			* @returns {Note[]} notes
140			*/
141			Conclusion.prototype.getNotes = function(){
142			return this.notes \|\| [];
143			};
144
145			/**
146			* Set the notes
147			*
148			* @param {Object[]\|Note[]} notes
149			* @returns {Conclusion} This instance
150			*/
151			Conclusion.prototype.setNotes = function(notes){
152			if(notes){
153			var conclusion = this;
154			conclusion.notes = [];
155			notes.forEach(function(note){
156			conclusion.addNote(note);
157			});
158			}
159			return this;
160			};
161
162			/**
163			* Add a note
164			*
165			* @param {Object\|Note} note
166			* @returns {Conclusion} This instance
167			*/
168			Conclusion.prototype.addNote = function(note){
169			if(note){
170			if(!Array.isArray(this.notes)){
171			this.notes = [];
172			}
173			this.notes.push(new Note(note));
174			}
175			return this;
176			};
177
178			/**
179			* Get the sources
180			*
181			* @returns {SourceReference[]}
182			*/
183			Conclusion.prototype.getSources = function(){
184			return this.sources \|\| [];
185			};
186
187			/**
188			* Set the sources
189			*
190			* @param {Object[]\|SourceReference[]} sources
191			* @returns {Conclusion} This instance
192			*/
193			Conclusion.prototype.setSources = function(sources){
194			if(sources){
195			var conclusion = this;
196			conclusion.sources = [];
197			sources.forEach(function(source){
198			conclusion.addSource(source);
199			});
200			}
201			return this;
202			};
203
204			/**
205			* Add a source
206			*
207			* @param {SourceReference} source
208			* @returns {Conclusion} This instance
209			*/
210			Conclusion.prototype.addSource = function(source){
211			if(source){
212			if(!Array.isArray(this.sources)){
213			this.sources = [];
214			}
215			this.sources.push(new SourceReference(source));
216			}
217			return this;
218			};
219
220			/**
221			* Export the object as JSON
222			*
223			* @return {Object} JSON object
224			*/
225			Conclusion.prototype.toJSON = function(){
226			var json = ExtensibleData.prototype.toJSON.call(this);
227
228			if(this.lang){
229			json.lang = this.lang;
230			}
231
232			if(this.confidence){
233			json.confidence = this.confidence;
234			}
235
236			if(this.analysis){
237			json.analysis = this.analysis.toJSON();
238			}
239
240			if(this.attribution){
241			json.attribution = this.attribution.toJSON();
242			}
243
244			if(this.sources){
245			json.sources = this.sources.map(function(source){
246			return source.toJSON();
247			});
248			}
249
250			if(this.notes){
251			json.notes = this.notes.map(function(note){
252			return note.toJSON();
253			});
254			}
255
256			return json;
257			};
258
259			module.exports = Conclusion;

rootsdev / gedcomx-js

Pull Request — master (#13)

Conclusion.js ➔ Conclusion B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like