14180294725

Committed 31 Mar 2025 07:59PM UTC coverage: 91.363% (-0.1%) from 91.51%

Build # 14180294725

Build Type

Pull #64

github

Committed by

web-flow

Commit Message

Merge 9696cb0fe into f6c5035c0

Pull Request Pull Request #64: chore(deps-dev): bump axios from 1.8.1 to 1.8.4

Run Details

159 of 202 branches covered (78.71%)

Branch coverage included in aggregate %.

5024 of 5471 relevant lines covered (91.83%)

37329.3 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.08

/src/mappings/streammetadata.cpp

#include "../utils/pointer.hpp"
#include "mappings.hpp"
#include <FLAC/metadata.h>

namespace flac_bindings {

  using namespace Napi;

  template<>
  Mapping<FLAC__StreamMetadata>& Mapping<FLAC__StreamMetadata>::fromJs(const Value&);
  template<>
  Value Mapping<FLAC__StreamMetadata>::toJs(const Env&, FLAC__StreamMetadata*, bool);

  Metadata::Metadata(const CallbackInfo& info, FLAC__MetadataType type):
      Mapping<FLAC__StreamMetadata>(info) {
    auto self = info.This().As<Object>();

    if (data == nullptr) {
      data = FLAC__metadata_object_new(type);
      shouldBeDeleted = true;
      if (data == nullptr) {
        throw Error::New(info.Env(), "No memory left - Could not create new metadata object");
      }
    }

    self.DefineProperties({
      PropertyDescriptor::Accessor(
        info.Env(),
        self,
        "type",
        &Metadata::getType,
        napi_property_attributes::napi_enumerable,
        this),
      PropertyDescriptor::Accessor(
        info.Env(),
        self,
        "isLast",
        &Metadata::getIsLast,
        napi_property_attributes::napi_enumerable,
        this),
      PropertyDescriptor::Accessor(
        info.Env(),
        self,
        "length",
        &Metadata::getLength,
        napi_property_attributes::napi_enumerable,
        this),
      PropertyDescriptor::Function(
        info.Env(),
        self,
        "clone",
        &Metadata::clone,
        napi_property_attributes::napi_default,
        this),
      PropertyDescriptor::Function(
        info.Env(),
        self,
        "isEqual",
        &Metadata::isEqual,
        napi_property_attributes::napi_default,
        this),
    });
  }

  Value Metadata::getType(const CallbackInfo& info) {
    Metadata* self = (Metadata*) info.Data();
    return numberToJs(info.Env(), self->data->type);
  }

  Value Metadata::getIsLast(const CallbackInfo& info) {
    Metadata* self = (Metadata*) info.Data();
    return booleanToJs(info.Env(), self->data->is_last);
  }

  Value Metadata::getLength(const CallbackInfo& info) {
    Metadata* self = (Metadata*) info.Data();
    return numberToJs(info.Env(), self->data->length);
  }

  Value Metadata::clone(const CallbackInfo& info) {
    Metadata* self = (Metadata*) info.Data();
    auto newMetadata = FLAC__metadata_object_clone(self->data);
    if (newMetadata == nullptr) {
      throw Error::New(info.Env(), "No memory left - Could not clone metadata object");
    }

    return Mapping::toJs(info.Env(), newMetadata, true);
  }

  Value Metadata::isEqual(const CallbackInfo& info) {
    Metadata* self = (Metadata*) info.Data();
    auto other = fromJs(info[0]);
    auto areEqual = FLAC__metadata_object_is_equal(self->data, other);
    return booleanToJs(info.Env(), areEqual);
  }

  template<>
  Mapping<FLAC__StreamMetadata>& Mapping<FLAC__StreamMetadata>::fromJs(const Value& value) {
    HandleScope scope(value.Env());
    if (!value.IsObject()) {
      throw Napi::TypeError::New(
        value.Env(),
        "Expected "s + value.ToString().Utf8Value() + " to be object"s);
    }

    auto obj = value.As<Object>();
    auto addon = value.Env().GetInstanceData<FlacAddon>();
    if (obj.InstanceOf(addon->streamInfoMetadataConstructor.Value())) {
      return *StreamInfoMetadata::Unwrap(obj);
    } else if (obj.InstanceOf(addon->paddingMetadataConstructor.Value())) {
      return *PaddingMetadata::Unwrap(obj);
    } else if (obj.InstanceOf(addon->applicationMetadataConstructor.Value())) {
      return *ApplicationMetadata::Unwrap(obj);
    } else if (obj.InstanceOf(addon->seekTableMetadataConstructor.Value())) {
      return *SeekTableMetadata::Unwrap(obj);
    } else if (obj.InstanceOf(addon->vorbisCommentMetadataConstructor.Value())) {
      return *VorbisCommentMetadata::Unwrap(obj);
    } else if (obj.InstanceOf(addon->cueSheetMetadataConstructor.Value())) {
      return *CueSheetMetadata::Unwrap(obj);
    } else if (obj.InstanceOf(addon->pictureMetadataConstructor.Value())) {
      return *PictureMetadata::Unwrap(obj);
    } else if (obj.InstanceOf(addon->unknownMetadataConstructor.Value())) {
      return *UnknownMetadata::Unwrap(obj);
    } else {
      throw TypeError::New(
        value.Env(),
        "Expected "s + value.ToString().Utf8Value() + " to be an instance of Metadata");
    }
  }

  template<>
  Value Mapping<FLAC__StreamMetadata>::toJs(
    const Env& env,
    FLAC__StreamMetadata* metadata,
    bool deleteHint) {
    if (metadata == nullptr) {
      return env.Null();
    }

    EscapableHandleScope scope(env);
    FunctionReference* constructor;
    auto addon = Napi::Env(env).GetInstanceData<FlacAddon>();

    switch (metadata->type) {
      case FLAC__MetadataType::FLAC__METADATA_TYPE_STREAMINFO:
        constructor = &addon->streamInfoMetadataConstructor;
        break;
      case FLAC__MetadataType::FLAC__METADATA_TYPE_PADDING:
        constructor = &addon->paddingMetadataConstructor;
        break;
      case FLAC__MetadataType::FLAC__METADATA_TYPE_APPLICATION:
        constructor = &addon->applicationMetadataConstructor;
        break;
      case FLAC__MetadataType::FLAC__METADATA_TYPE_SEEKTABLE:
        constructor = &addon->seekTableMetadataConstructor;
        break;
      case FLAC__MetadataType::FLAC__METADATA_TYPE_VORBIS_COMMENT:
        constructor = &addon->vorbisCommentMetadataConstructor;
        break;
      case FLAC__MetadataType::FLAC__METADATA_TYPE_CUESHEET:
        constructor = &addon->cueSheetMetadataConstructor;
        break;
      case FLAC__MetadataType::FLAC__METADATA_TYPE_PICTURE:
        constructor = &addon->pictureMetadataConstructor;
        break;
      default:
        constructor = &addon->unknownMetadataConstructor;
        break;
    }

    auto object = constructor->New({pointer::wrap(env, metadata), booleanToJs(env, deleteHint)});
    return scope.Escape(object);
  }

  Metadata::~Metadata() {
    if (shouldBeDeleted) {
      FLAC__metadata_object_delete(data);
    }
  }

}

1	#include "../utils/pointer.hpp"
2	#include "mappings.hpp"
3	#include <FLAC/metadata.h>
4
5	namespace flac_bindings {
6
7	using namespace Napi;
8
9	template<>
10	Mapping<FLAC__StreamMetadata>& Mapping<FLAC__StreamMetadata>::fromJs(const Value&);
11	template<>
12	Value Mapping<FLAC__StreamMetadata>::toJs(const Env&, FLAC__StreamMetadata*, bool);
13
14	Metadata::Metadata(const CallbackInfo& info, FLAC__MetadataType type):	397✔
15	Mapping<FLAC__StreamMetadata>(info) {	397✔
16	auto self = info.This().As<Object>();	397✔
17
18	if (data == nullptr) {	397✔
19	data = FLAC__metadata_object_new(type);	211✔
20	shouldBeDeleted = true;	211✔
21	if (data == nullptr) {	211✔
22	throw Error::New(info.Env(), "No memory left - Could not create new metadata object");	×
23	}
24	}
25
26	self.DefineProperties({	397✔
27	PropertyDescriptor::Accessor(	397✔
28	info.Env(),
29	self,
30	"type",
31	&Metadata::getType,
32	napi_property_attributes::napi_enumerable,
33	this),
34	PropertyDescriptor::Accessor(	397✔
35	info.Env(),
36	self,
37	"isLast",
38	&Metadata::getIsLast,
39	napi_property_attributes::napi_enumerable,
40	this),
41	PropertyDescriptor::Accessor(	397✔
42	info.Env(),
43	self,
44	"length",
45	&Metadata::getLength,
46	napi_property_attributes::napi_enumerable,
47	this),
48	PropertyDescriptor::Function(	397✔
49	info.Env(),
50	self,
51	"clone",
52	&Metadata::clone,
53	napi_property_attributes::napi_default,
54	this),
55	PropertyDescriptor::Function(	397✔
56	info.Env(),
57	self,
58	"isEqual",
59	&Metadata::isEqual,
60	napi_property_attributes::napi_default,
61	this),
62	});
63	}	397✔
64
65	Value Metadata::getType(const CallbackInfo& info) {	139✔
66	Metadata* self = (Metadata*) info.Data();	139✔
67	return numberToJs(info.Env(), self->data->type);	139✔
68	}
69
70	Value Metadata::getIsLast(const CallbackInfo& info) {	1✔
71	Metadata* self = (Metadata*) info.Data();	1✔
72	return booleanToJs(info.Env(), self->data->is_last);	1✔
73	}
74
75	Value Metadata::getLength(const CallbackInfo& info) {	4✔
76	Metadata* self = (Metadata*) info.Data();	4✔
77	return numberToJs(info.Env(), self->data->length);	4✔
78	}
79
80	Value Metadata::clone(const CallbackInfo& info) {	1✔
81	Metadata* self = (Metadata*) info.Data();	1✔
82	auto newMetadata = FLAC__metadata_object_clone(self->data);	1✔
83	if (newMetadata == nullptr) {	1✔
84	throw Error::New(info.Env(), "No memory left - Could not clone metadata object");	×
85	}
86
87	return Mapping::toJs(info.Env(), newMetadata, true);	1✔
88	}
89
90	Value Metadata::isEqual(const CallbackInfo& info) {	8✔
91	Metadata* self = (Metadata*) info.Data();	8✔
92	auto other = fromJs(info[0]);	8✔
93	auto areEqual = FLAC__metadata_object_is_equal(self->data, other);	6✔
94	return booleanToJs(info.Env(), areEqual);	12✔
95	}	6✔
96
97	template<>
98	Mapping<FLAC__StreamMetadata>& Mapping<FLAC__StreamMetadata>::fromJs(const Value& value) {	58✔
99	HandleScope scope(value.Env());	58✔
100	if (!value.IsObject()) {	58✔
101	throw Napi::TypeError::New(	1✔
102	value.Env(),	1✔
103	"Expected "s + value.ToString().Utf8Value() + " to be object"s);	2✔
104	}
105
106	auto obj = value.As<Object>();	57✔
107	auto addon = value.Env().GetInstanceData<FlacAddon>();	57✔
108	if (obj.InstanceOf(addon->streamInfoMetadataConstructor.Value())) {	57✔
109	return *StreamInfoMetadata::Unwrap(obj);	×
110	} else if (obj.InstanceOf(addon->paddingMetadataConstructor.Value())) {	57✔
111	return *PaddingMetadata::Unwrap(obj);	9✔
112	} else if (obj.InstanceOf(addon->applicationMetadataConstructor.Value())) {	48✔
113	return *ApplicationMetadata::Unwrap(obj);	25✔
114	} else if (obj.InstanceOf(addon->seekTableMetadataConstructor.Value())) {	23✔
115	return *SeekTableMetadata::Unwrap(obj);	2✔
116	} else if (obj.InstanceOf(addon->vorbisCommentMetadataConstructor.Value())) {	21✔
117	return *VorbisCommentMetadata::Unwrap(obj);	7✔
118	} else if (obj.InstanceOf(addon->cueSheetMetadataConstructor.Value())) {	14✔
119	return *CueSheetMetadata::Unwrap(obj);	3✔
120	} else if (obj.InstanceOf(addon->pictureMetadataConstructor.Value())) {	11✔
121	return *PictureMetadata::Unwrap(obj);	3✔
122	} else if (obj.InstanceOf(addon->unknownMetadataConstructor.Value())) {	8✔
123	return *UnknownMetadata::Unwrap(obj);	×
124	} else {
125	throw TypeError::New(	8✔
126	value.Env(),	8✔
127	"Expected "s + value.ToString().Utf8Value() + " to be an instance of Metadata");	16✔
128	}
129	}	58✔
130
131	template<>
132	Value Mapping<FLAC__StreamMetadata>::toJs(	199✔
133	const Env& env,
134	FLAC__StreamMetadata* metadata,
135	bool deleteHint) {
136	if (metadata == nullptr) {	199✔
137	return env.Null();	13✔
138	}
139
140	EscapableHandleScope scope(env);	186✔
141	FunctionReference* constructor;
142	auto addon = Napi::Env(env).GetInstanceData<FlacAddon>();	186✔
143
144	switch (metadata->type) {	186✔
145	case FLAC__MetadataType::FLAC__METADATA_TYPE_STREAMINFO:	60✔
146	constructor = &addon->streamInfoMetadataConstructor;	60✔
147	break;	60✔
148	case FLAC__MetadataType::FLAC__METADATA_TYPE_PADDING:	28✔
149	constructor = &addon->paddingMetadataConstructor;	28✔
150	break;	28✔
151	case FLAC__MetadataType::FLAC__METADATA_TYPE_APPLICATION:	20✔
152	constructor = &addon->applicationMetadataConstructor;	20✔
153	break;	20✔
154	case FLAC__MetadataType::FLAC__METADATA_TYPE_SEEKTABLE:	13✔
155	constructor = &addon->seekTableMetadataConstructor;	13✔
156	break;	13✔
157	case FLAC__MetadataType::FLAC__METADATA_TYPE_VORBIS_COMMENT:	34✔
158	constructor = &addon->vorbisCommentMetadataConstructor;	34✔
159	break;	34✔
160	case FLAC__MetadataType::FLAC__METADATA_TYPE_CUESHEET:	16✔
161	constructor = &addon->cueSheetMetadataConstructor;	16✔
162	break;	16✔
163	case FLAC__MetadataType::FLAC__METADATA_TYPE_PICTURE:	15✔
164	constructor = &addon->pictureMetadataConstructor;	15✔
165	break;	15✔
166	default:	×
167	constructor = &addon->unknownMetadataConstructor;	×
168	break;	×
169	}
170
171	auto object = constructor->New({pointer::wrap(env, metadata), booleanToJs(env, deleteHint)});	186✔
172	return scope.Escape(object);	186✔
173	}	186✔
174
175	Metadata::~Metadata() {	81✔
176	if (shouldBeDeleted) {	81✔
177	FLAC__metadata_object_delete(data);	×
178	}
179	}	81✔
180
181	}

melchor629 / node-flac-bindings / 14180294725

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous