id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1 value | code stringlengths 52 85.5k | code_tokens list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
0 | jessevdk/go-assets | file.go | Close | func (f *File) Close() error {
f.buf = nil
f.dirIndex = 0
return nil
} | go | func (f *File) Close() error {
f.buf = nil
f.dirIndex = 0
return nil
} | [
"func",
"(",
"f",
"*",
"File",
")",
"Close",
"(",
")",
"error",
"{",
"f",
".",
"buf",
"=",
"nil",
"\n",
"f",
".",
"dirIndex",
"=",
"0",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Implementation of http.File | [
"Implementation",
"of",
"http",
".",
"File"
] | 4f4301a06e153ff90e17793577ab6bf79f8dc5c5 | https://github.com/jessevdk/go-assets/blob/4f4301a06e153ff90e17793577ab6bf79f8dc5c5/file.go#L57-L62 |
1 | jessevdk/go-assets | filesystem.go | Open | func (f *FileSystem) Open(p string) (http.File, error) {
p = path.Clean(p)
if len(f.LocalPath) != 0 {
return http.Dir(f.LocalPath).Open(p)
}
if fi, ok := f.Files[p]; ok {
if !fi.IsDir() {
// Make a copy for reading
ret := fi
ret.buf = bytes.NewReader(ret.Data)
return ret, nil
}
return fi, nil
}
return nil, os.ErrNotExist
} | go | func (f *FileSystem) Open(p string) (http.File, error) {
p = path.Clean(p)
if len(f.LocalPath) != 0 {
return http.Dir(f.LocalPath).Open(p)
}
if fi, ok := f.Files[p]; ok {
if !fi.IsDir() {
// Make a copy for reading
ret := fi
ret.buf = bytes.NewReader(ret.Data)
return ret, nil
}
return fi, nil
}
return nil, os.ErrNotExist
} | [
"func",
"(",
"f",
"*",
"FileSystem",
")",
"Open",
"(",
"p",
"string",
")",
"(",
"http",
".",
"File",
",",
"error",
")",
"{",
"p",
"=",
"path",
".",
"Clean",
"(",
"p",
")",
"\n\n",
"if",
"len",
"(",
"f",
".",
"LocalPath",
")",
"!=",
"0",
"{",
... | // Implementation of http.FileSystem | [
"Implementation",
"of",
"http",
".",
"FileSystem"
] | 4f4301a06e153ff90e17793577ab6bf79f8dc5c5 | https://github.com/jessevdk/go-assets/blob/4f4301a06e153ff90e17793577ab6bf79f8dc5c5/filesystem.go#L50-L70 |
2 | jessevdk/go-assets | generate.go | Add | func (x *Generator) Add(p string) error {
if x.fsFilesMap == nil {
x.fsFilesMap = make(map[string]file)
}
if x.fsDirsMap == nil {
x.fsDirsMap = make(map[string][]string)
}
p = path.Clean(p)
info, err := os.Stat(p)
if err != nil {
return err
}
prefix, p := x.splitRelPrefix(p)
if err := x.addParents(p, prefix); err != nil {
return err
}
return x.addPath(path.Dir(p), prefix, info)
} | go | func (x *Generator) Add(p string) error {
if x.fsFilesMap == nil {
x.fsFilesMap = make(map[string]file)
}
if x.fsDirsMap == nil {
x.fsDirsMap = make(map[string][]string)
}
p = path.Clean(p)
info, err := os.Stat(p)
if err != nil {
return err
}
prefix, p := x.splitRelPrefix(p)
if err := x.addParents(p, prefix); err != nil {
return err
}
return x.addPath(path.Dir(p), prefix, info)
} | [
"func",
"(",
"x",
"*",
"Generator",
")",
"Add",
"(",
"p",
"string",
")",
"error",
"{",
"if",
"x",
".",
"fsFilesMap",
"==",
"nil",
"{",
"x",
".",
"fsFilesMap",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"file",
")",
"\n",
"}",
"\n\n",
"if",
"x... | // Add a file or directory asset to the generator. Added directories will be
// recursed automatically. | [
"Add",
"a",
"file",
"or",
"directory",
"asset",
"to",
"the",
"generator",
".",
"Added",
"directories",
"will",
"be",
"recursed",
"automatically",
"."
] | 4f4301a06e153ff90e17793577ab6bf79f8dc5c5 | https://github.com/jessevdk/go-assets/blob/4f4301a06e153ff90e17793577ab6bf79f8dc5c5/generate.go#L129-L153 |
3 | jessevdk/go-assets | generate.go | Write | func (x *Generator) Write(wr io.Writer) error {
p := x.PackageName
if len(p) == 0 {
p = "main"
}
variableName := x.VariableName
if len(variableName) == 0 {
variableName = "Assets"
}
writer := &bytes.Buffer{}
// Write package and import
fmt.Fprintf(writer, "package %s\n\n", p)
fmt.Fprintln(writer, "import (")
fmt.Fprintln(writer, "\t\"time\"")
fmt.Fprintln(writer)
fmt.Fprintln(writer, "\t\"github.com/jessevdk/go-assets\"")
fmt.Fprintln(writer, ")")
fmt.Fprintln(writer)
vnames := make(map[string]string)
// Write file contents as const strings
if x.fsFilesMap != nil {
// Create mapping from full file path to asset variable name.
// This also reads the file and writes the contents as a const
// string
for k, v := range x.fsFilesMap {
if v.info.IsDir() {
continue
}
f, err := os.Open(v.path)
if err != nil {
return err
}
data, err := ioutil.ReadAll(f)
f.Close()
if err != nil {
return err
}
s := sha1.New()
io.WriteString(s, k)
vname := fmt.Sprintf("_%s%x", variableName, s.Sum(nil))
vnames[k] = vname
fmt.Fprintf(writer, "var %s = %#v\n", vname, string(data))
}
fmt.Fprintln(writer)
}
fmt.Fprintf(writer, "// %s returns go-assets FileSystem\n", variableName)
fmt.Fprintf(writer, "var %s = assets.NewFileSystem(", variableName)
if x.fsDirsMap == nil {
x.fsDirsMap = make(map[string][]string)
}
if x.fsFilesMap == nil {
x.fsFilesMap = make(map[string]file)
}
dirmap := make(map[string][]string)
for k, v := range x.fsDirsMap {
if kk, ok := x.stripPrefix(k); ok {
if len(kk) == 0 {
kk = "/"
}
dirmap[kk] = v
}
}
fmt.Fprintf(writer, "%#v, ", dirmap)
fmt.Fprintf(writer, "map[string]*assets.File{\n")
// Write files
for k, v := range x.fsFilesMap {
kk, ok := x.stripPrefix(k)
if !ok {
continue
}
if len(kk) == 0 {
kk = "/"
}
mt := v.info.ModTime()
var dt string
if !v.info.IsDir() {
dt = "[]byte(" + vnames[k] + ")"
} else {
dt = "nil"
}
fmt.Fprintf(writer, "\t\t%#v: &assets.File{\n", kk)
fmt.Fprintf(writer, "\t\t\tPath: %#v,\n", kk)
fmt.Fprintf(writer, "\t\t\tFileMode: %#v,\n", v.info.Mode())
fmt.Fprintf(writer, "\t\t\tMtime: time.Unix(%#v, %#v),\n", mt.Unix(), mt.UnixNano())
fmt.Fprintf(writer, "\t\t\tData: %s,\n", dt)
fmt.Fprintf(writer, "\t\t},")
}
fmt.Fprintln(writer, "\t}, \"\")")
ret, err := format.Source(writer.Bytes())
if err != nil {
return err
}
wr.Write(ret)
return nil
} | go | func (x *Generator) Write(wr io.Writer) error {
p := x.PackageName
if len(p) == 0 {
p = "main"
}
variableName := x.VariableName
if len(variableName) == 0 {
variableName = "Assets"
}
writer := &bytes.Buffer{}
// Write package and import
fmt.Fprintf(writer, "package %s\n\n", p)
fmt.Fprintln(writer, "import (")
fmt.Fprintln(writer, "\t\"time\"")
fmt.Fprintln(writer)
fmt.Fprintln(writer, "\t\"github.com/jessevdk/go-assets\"")
fmt.Fprintln(writer, ")")
fmt.Fprintln(writer)
vnames := make(map[string]string)
// Write file contents as const strings
if x.fsFilesMap != nil {
// Create mapping from full file path to asset variable name.
// This also reads the file and writes the contents as a const
// string
for k, v := range x.fsFilesMap {
if v.info.IsDir() {
continue
}
f, err := os.Open(v.path)
if err != nil {
return err
}
data, err := ioutil.ReadAll(f)
f.Close()
if err != nil {
return err
}
s := sha1.New()
io.WriteString(s, k)
vname := fmt.Sprintf("_%s%x", variableName, s.Sum(nil))
vnames[k] = vname
fmt.Fprintf(writer, "var %s = %#v\n", vname, string(data))
}
fmt.Fprintln(writer)
}
fmt.Fprintf(writer, "// %s returns go-assets FileSystem\n", variableName)
fmt.Fprintf(writer, "var %s = assets.NewFileSystem(", variableName)
if x.fsDirsMap == nil {
x.fsDirsMap = make(map[string][]string)
}
if x.fsFilesMap == nil {
x.fsFilesMap = make(map[string]file)
}
dirmap := make(map[string][]string)
for k, v := range x.fsDirsMap {
if kk, ok := x.stripPrefix(k); ok {
if len(kk) == 0 {
kk = "/"
}
dirmap[kk] = v
}
}
fmt.Fprintf(writer, "%#v, ", dirmap)
fmt.Fprintf(writer, "map[string]*assets.File{\n")
// Write files
for k, v := range x.fsFilesMap {
kk, ok := x.stripPrefix(k)
if !ok {
continue
}
if len(kk) == 0 {
kk = "/"
}
mt := v.info.ModTime()
var dt string
if !v.info.IsDir() {
dt = "[]byte(" + vnames[k] + ")"
} else {
dt = "nil"
}
fmt.Fprintf(writer, "\t\t%#v: &assets.File{\n", kk)
fmt.Fprintf(writer, "\t\t\tPath: %#v,\n", kk)
fmt.Fprintf(writer, "\t\t\tFileMode: %#v,\n", v.info.Mode())
fmt.Fprintf(writer, "\t\t\tMtime: time.Unix(%#v, %#v),\n", mt.Unix(), mt.UnixNano())
fmt.Fprintf(writer, "\t\t\tData: %s,\n", dt)
fmt.Fprintf(writer, "\t\t},")
}
fmt.Fprintln(writer, "\t}, \"\")")
ret, err := format.Source(writer.Bytes())
if err != nil {
return err
}
wr.Write(ret)
return nil
} | [
"func",
"(",
"x",
"*",
"Generator",
")",
"Write",
"(",
"wr",
"io",
".",
"Writer",
")",
"error",
"{",
"p",
":=",
"x",
".",
"PackageName",
"\n\n",
"if",
"len",
"(",
"p",
")",
"==",
"0",
"{",
"p",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"variableName"... | // Write the asset tree specified in the generator to the given writer. The
// written asset tree is a valid, standalone go file with the assets
// embedded into it. | [
"Write",
"the",
"asset",
"tree",
"specified",
"in",
"the",
"generator",
"to",
"the",
"given",
"writer",
".",
"The",
"written",
"asset",
"tree",
"is",
"a",
"valid",
"standalone",
"go",
"file",
"with",
"the",
"assets",
"embedded",
"into",
"it",
"."
] | 4f4301a06e153ff90e17793577ab6bf79f8dc5c5 | https://github.com/jessevdk/go-assets/blob/4f4301a06e153ff90e17793577ab6bf79f8dc5c5/generate.go#L170-L298 |
4 | ttacon/libphonenumber | phonenumberutil.go | isViablePhoneNumber | func isViablePhoneNumber(number string) bool {
if len(number) < MIN_LENGTH_FOR_NSN {
return false
}
return VALID_PHONE_NUMBER_PATTERN.MatchString(number)
} | go | func isViablePhoneNumber(number string) bool {
if len(number) < MIN_LENGTH_FOR_NSN {
return false
}
return VALID_PHONE_NUMBER_PATTERN.MatchString(number)
} | [
"func",
"isViablePhoneNumber",
"(",
"number",
"string",
")",
"bool",
"{",
"if",
"len",
"(",
"number",
")",
"<",
"MIN_LENGTH_FOR_NSN",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"VALID_PHONE_NUMBER_PATTERN",
".",
"MatchString",
"(",
"number",
")",
"\n",... | // Checks to see if the string of characters could possibly be a phone
// number at all. At the moment, checks to see that the string begins
// with at least 2 digits, ignoring any punctuation commonly found in
// phone numbers. This method does not require the number to be
// normalized in advance - but does assume that leading non-number symbols
// have been removed, such as by the method extractPossibleNumber.
// @VisibleForTesting | [
"Checks",
"to",
"see",
"if",
"the",
"string",
"of",
"characters",
"could",
"possibly",
"be",
"a",
"phone",
"number",
"at",
"all",
".",
"At",
"the",
"moment",
"checks",
"to",
"see",
"that",
"the",
"string",
"begins",
"with",
"at",
"least",
"2",
"digits",
... | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L725-L730 |
5 | ttacon/libphonenumber | phonenumberutil.go | GetCountryMobileToken | func GetCountryMobileToken(countryCallingCode int) string {
if val, ok := MOBILE_TOKEN_MAPPINGS[countryCallingCode]; ok {
return val
}
return ""
} | go | func GetCountryMobileToken(countryCallingCode int) string {
if val, ok := MOBILE_TOKEN_MAPPINGS[countryCallingCode]; ok {
return val
}
return ""
} | [
"func",
"GetCountryMobileToken",
"(",
"countryCallingCode",
"int",
")",
"string",
"{",
"if",
"val",
",",
"ok",
":=",
"MOBILE_TOKEN_MAPPINGS",
"[",
"countryCallingCode",
"]",
";",
"ok",
"{",
"return",
"val",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // Returns the mobile token for the provided country calling code if it
// has one, otherwise returns an empty string. A mobile token is a number
// inserted before the area code when dialing a mobile number from that
// country from abroad. | [
"Returns",
"the",
"mobile",
"token",
"for",
"the",
"provided",
"country",
"calling",
"code",
"if",
"it",
"has",
"one",
"otherwise",
"returns",
"an",
"empty",
"string",
".",
"A",
"mobile",
"token",
"is",
"a",
"number",
"inserted",
"before",
"the",
"area",
"... | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L958-L963 |
6 | ttacon/libphonenumber | phonenumberutil.go | normalizeHelper | func normalizeHelper(number string,
normalizationReplacements map[rune]rune,
removeNonMatches bool) string {
var normalizedNumber = builder.NewBuilder(nil)
for _, character := range number {
newDigit, ok := normalizationReplacements[unicode.ToUpper(character)]
if ok {
normalizedNumber.WriteRune(newDigit)
} else if !removeNonMatches {
normalizedNumber.WriteRune(character)
}
// If neither of the above are true, we remove this character.
}
return normalizedNumber.String()
} | go | func normalizeHelper(number string,
normalizationReplacements map[rune]rune,
removeNonMatches bool) string {
var normalizedNumber = builder.NewBuilder(nil)
for _, character := range number {
newDigit, ok := normalizationReplacements[unicode.ToUpper(character)]
if ok {
normalizedNumber.WriteRune(newDigit)
} else if !removeNonMatches {
normalizedNumber.WriteRune(character)
}
// If neither of the above are true, we remove this character.
}
return normalizedNumber.String()
} | [
"func",
"normalizeHelper",
"(",
"number",
"string",
",",
"normalizationReplacements",
"map",
"[",
"rune",
"]",
"rune",
",",
"removeNonMatches",
"bool",
")",
"string",
"{",
"var",
"normalizedNumber",
"=",
"builder",
".",
"NewBuilder",
"(",
"nil",
")",
"\n",
"fo... | // Normalizes a string of characters representing a phone number by replacing
// all characters found in the accompanying map with the values therein,
// and stripping all other characters if removeNonMatches is true. | [
"Normalizes",
"a",
"string",
"of",
"characters",
"representing",
"a",
"phone",
"number",
"by",
"replacing",
"all",
"characters",
"found",
"in",
"the",
"accompanying",
"map",
"with",
"the",
"values",
"therein",
"and",
"stripping",
"all",
"other",
"characters",
"i... | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L968-L983 |
7 | ttacon/libphonenumber | phonenumberutil.go | isNumberGeographical | func isNumberGeographical(phoneNumber *PhoneNumber) bool {
numberType := GetNumberType(phoneNumber)
// TODO: Include mobile phone numbers from countries like Indonesia,
// which has some mobile numbers that are geographical.
return numberType == FIXED_LINE ||
numberType == FIXED_LINE_OR_MOBILE
} | go | func isNumberGeographical(phoneNumber *PhoneNumber) bool {
numberType := GetNumberType(phoneNumber)
// TODO: Include mobile phone numbers from countries like Indonesia,
// which has some mobile numbers that are geographical.
return numberType == FIXED_LINE ||
numberType == FIXED_LINE_OR_MOBILE
} | [
"func",
"isNumberGeographical",
"(",
"phoneNumber",
"*",
"PhoneNumber",
")",
"bool",
"{",
"numberType",
":=",
"GetNumberType",
"(",
"phoneNumber",
")",
"\n",
"// TODO: Include mobile phone numbers from countries like Indonesia,",
"// which has some mobile numbers that are geographi... | // Tests whether a phone number has a geographical association. It checks
// if the number is associated to a certain region in the country where it
// belongs to. Note that this doesn't verify if the number is actually in use.
//
// A similar method is implemented as PhoneNumberOfflineGeocoder.canBeGeocoded,
// which performs a looser check, since it only prevents cases where prefixes
// overlap for geocodable and non-geocodable numbers. Also, if new phone
// number types were added, we should check if this other method should be
// updated too. | [
"Tests",
"whether",
"a",
"phone",
"number",
"has",
"a",
"geographical",
"association",
".",
"It",
"checks",
"if",
"the",
"number",
"is",
"associated",
"to",
"a",
"certain",
"region",
"in",
"the",
"country",
"where",
"it",
"belongs",
"to",
".",
"Note",
"tha... | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1012-L1018 |
8 | ttacon/libphonenumber | phonenumberutil.go | isValidRegionCode | func isValidRegionCode(regionCode string) bool {
_, contains := readFromSupportedRegions(regionCode)
return len(regionCode) != 0 && contains
} | go | func isValidRegionCode(regionCode string) bool {
_, contains := readFromSupportedRegions(regionCode)
return len(regionCode) != 0 && contains
} | [
"func",
"isValidRegionCode",
"(",
"regionCode",
"string",
")",
"bool",
"{",
"_",
",",
"contains",
":=",
"readFromSupportedRegions",
"(",
"regionCode",
")",
"\n",
"return",
"len",
"(",
"regionCode",
")",
"!=",
"0",
"&&",
"contains",
"\n",
"}"
] | // Helper function to check region code is not unknown or null. | [
"Helper",
"function",
"to",
"check",
"region",
"code",
"is",
"not",
"unknown",
"or",
"null",
"."
] | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1021-L1024 |
9 | ttacon/libphonenumber | phonenumberutil.go | Format | func Format(number *PhoneNumber, numberFormat PhoneNumberFormat) string {
if number.GetNationalNumber() == 0 && len(number.GetRawInput()) > 0 {
// Unparseable numbers that kept their raw input just use that.
// This is the only case where a number can be formatted as E164
// without a leading '+' symbol (but the original number wasn't
// parseable anyway).
// TODO: Consider removing the 'if' above so that unparseable
// strings without raw input format to the empty string instead of "+00"
rawInput := number.GetRawInput()
if len(rawInput) > 0 {
return rawInput
}
}
var formattedNumber = builder.NewBuilder(nil)
FormatWithBuf(number, numberFormat, formattedNumber)
return formattedNumber.String()
} | go | func Format(number *PhoneNumber, numberFormat PhoneNumberFormat) string {
if number.GetNationalNumber() == 0 && len(number.GetRawInput()) > 0 {
// Unparseable numbers that kept their raw input just use that.
// This is the only case where a number can be formatted as E164
// without a leading '+' symbol (but the original number wasn't
// parseable anyway).
// TODO: Consider removing the 'if' above so that unparseable
// strings without raw input format to the empty string instead of "+00"
rawInput := number.GetRawInput()
if len(rawInput) > 0 {
return rawInput
}
}
var formattedNumber = builder.NewBuilder(nil)
FormatWithBuf(number, numberFormat, formattedNumber)
return formattedNumber.String()
} | [
"func",
"Format",
"(",
"number",
"*",
"PhoneNumber",
",",
"numberFormat",
"PhoneNumberFormat",
")",
"string",
"{",
"if",
"number",
".",
"GetNationalNumber",
"(",
")",
"==",
"0",
"&&",
"len",
"(",
"number",
".",
"GetRawInput",
"(",
")",
")",
">",
"0",
"{"... | // Formats a phone number in the specified format using default rules. Note
// that this does not promise to produce a phone number that the user can
// dial from where they are - although we do format in either 'national' or
// 'international' format depending on what the client asks for, we do not
// currently support a more abbreviated format, such as for users in the
// same "area" who could potentially dial the number without area code.
// Note that if the phone number has a country calling code of 0 or an
// otherwise invalid country calling code, we cannot work out which
// formatting rules to apply so we return the national significant number
// with no formatting applied. | [
"Formats",
"a",
"phone",
"number",
"in",
"the",
"specified",
"format",
"using",
"default",
"rules",
".",
"Note",
"that",
"this",
"does",
"not",
"promise",
"to",
"produce",
"a",
"phone",
"number",
"that",
"the",
"user",
"can",
"dial",
"from",
"where",
"they... | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1042-L1058 |
10 | ttacon/libphonenumber | phonenumberutil.go | FormatByPattern | func FormatByPattern(number *PhoneNumber,
numberFormat PhoneNumberFormat,
userDefinedFormats []*NumberFormat) string {
countryCallingCode := int(number.GetCountryCode())
nationalSignificantNumber := GetNationalSignificantNumber(number)
if !hasValidCountryCallingCode(countryCallingCode) {
return nationalSignificantNumber
}
// Note GetRegionCodeForCountryCode() is used because formatting
// information for regions which share a country calling code is
// contained by only one region for performance reasons. For example,
// for NANPA regions it will be contained in the metadata for US.
regionCode := GetRegionCodeForCountryCode(countryCallingCode)
// Metadata cannot be null because the country calling code is valid
metadata := getMetadataForRegionOrCallingCode(countryCallingCode, regionCode)
formattedNumber := builder.NewBuilder(nil)
formattingPattern := chooseFormattingPatternForNumber(
userDefinedFormats, nationalSignificantNumber)
if formattingPattern == nil {
// If no pattern above is matched, we format the number as a whole.
formattedNumber.WriteString(nationalSignificantNumber)
} else {
var numFormatCopy *NumberFormat
// Before we do a replacement of the national prefix pattern
// $NP with the national prefix, we need to copy the rule so
// that subsequent replacements for different numbers have the
// appropriate national prefix.
proto.Merge(numFormatCopy, formattingPattern)
nationalPrefixFormattingRule := formattingPattern.GetNationalPrefixFormattingRule()
if len(nationalPrefixFormattingRule) > 0 {
nationalPrefix := metadata.GetNationalPrefix()
if len(nationalPrefix) > 0 {
// Replace $NP with national prefix and $FG with the
// first group ($1).
nationalPrefixFormattingRule =
NP_PATTERN.ReplaceAllString(
nationalPrefixFormattingRule, nationalPrefix)
nationalPrefixFormattingRule =
FG_PATTERN.ReplaceAllString(
nationalPrefixFormattingRule, "\\$1")
numFormatCopy.NationalPrefixFormattingRule =
&nationalPrefixFormattingRule
} else {
// We don't want to have a rule for how to format the
// national prefix if there isn't one.
numFormatCopy.NationalPrefixFormattingRule = nil
}
}
formattedNumber.WriteString(
formatNsnUsingPattern(
nationalSignificantNumber, numFormatCopy, numberFormat))
}
maybeAppendFormattedExtension(number, metadata, numberFormat, formattedNumber)
prefixNumberWithCountryCallingCode(countryCallingCode, numberFormat, formattedNumber)
return formattedNumber.String()
} | go | func FormatByPattern(number *PhoneNumber,
numberFormat PhoneNumberFormat,
userDefinedFormats []*NumberFormat) string {
countryCallingCode := int(number.GetCountryCode())
nationalSignificantNumber := GetNationalSignificantNumber(number)
if !hasValidCountryCallingCode(countryCallingCode) {
return nationalSignificantNumber
}
// Note GetRegionCodeForCountryCode() is used because formatting
// information for regions which share a country calling code is
// contained by only one region for performance reasons. For example,
// for NANPA regions it will be contained in the metadata for US.
regionCode := GetRegionCodeForCountryCode(countryCallingCode)
// Metadata cannot be null because the country calling code is valid
metadata := getMetadataForRegionOrCallingCode(countryCallingCode, regionCode)
formattedNumber := builder.NewBuilder(nil)
formattingPattern := chooseFormattingPatternForNumber(
userDefinedFormats, nationalSignificantNumber)
if formattingPattern == nil {
// If no pattern above is matched, we format the number as a whole.
formattedNumber.WriteString(nationalSignificantNumber)
} else {
var numFormatCopy *NumberFormat
// Before we do a replacement of the national prefix pattern
// $NP with the national prefix, we need to copy the rule so
// that subsequent replacements for different numbers have the
// appropriate national prefix.
proto.Merge(numFormatCopy, formattingPattern)
nationalPrefixFormattingRule := formattingPattern.GetNationalPrefixFormattingRule()
if len(nationalPrefixFormattingRule) > 0 {
nationalPrefix := metadata.GetNationalPrefix()
if len(nationalPrefix) > 0 {
// Replace $NP with national prefix and $FG with the
// first group ($1).
nationalPrefixFormattingRule =
NP_PATTERN.ReplaceAllString(
nationalPrefixFormattingRule, nationalPrefix)
nationalPrefixFormattingRule =
FG_PATTERN.ReplaceAllString(
nationalPrefixFormattingRule, "\\$1")
numFormatCopy.NationalPrefixFormattingRule =
&nationalPrefixFormattingRule
} else {
// We don't want to have a rule for how to format the
// national prefix if there isn't one.
numFormatCopy.NationalPrefixFormattingRule = nil
}
}
formattedNumber.WriteString(
formatNsnUsingPattern(
nationalSignificantNumber, numFormatCopy, numberFormat))
}
maybeAppendFormattedExtension(number, metadata, numberFormat, formattedNumber)
prefixNumberWithCountryCallingCode(countryCallingCode, numberFormat, formattedNumber)
return formattedNumber.String()
} | [
"func",
"FormatByPattern",
"(",
"number",
"*",
"PhoneNumber",
",",
"numberFormat",
"PhoneNumberFormat",
",",
"userDefinedFormats",
"[",
"]",
"*",
"NumberFormat",
")",
"string",
"{",
"countryCallingCode",
":=",
"int",
"(",
"number",
".",
"GetCountryCode",
"(",
")",... | // Formats a phone number in the specified format using client-defined
// formatting rules. Note that if the phone number has a country calling
// code of zero or an otherwise invalid country calling code, we cannot
// work out things like whether there should be a national prefix applied,
// or how to format extensions, so we return the national significant
// number with no formatting applied. | [
"Formats",
"a",
"phone",
"number",
"in",
"the",
"specified",
"format",
"using",
"client",
"-",
"defined",
"formatting",
"rules",
".",
"Note",
"that",
"if",
"the",
"phone",
"number",
"has",
"a",
"country",
"calling",
"code",
"of",
"zero",
"or",
"an",
"other... | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1109-L1167 |
11 | ttacon/libphonenumber | phonenumberutil.go | FormatNationalNumberWithCarrierCode | func FormatNationalNumberWithCarrierCode(number *PhoneNumber, carrierCode string) string {
countryCallingCode := int(number.GetCountryCode())
nationalSignificantNumber := GetNationalSignificantNumber(number)
if !hasValidCountryCallingCode(countryCallingCode) {
return nationalSignificantNumber
}
// Note GetRegionCodeForCountryCode() is used because formatting
// information for regions which share a country calling code is
// contained by only one region for performance reasons. For
// example, for NANPA regions it will be contained in the metadata for US.
regionCode := GetRegionCodeForCountryCode(countryCallingCode)
// Metadata cannot be null because the country calling code is valid.
metadata := getMetadataForRegionOrCallingCode(countryCallingCode, regionCode)
formattedNumber := builder.NewBuilder(nil)
formattedNumber.WriteString(
formatNsnWithCarrier(
nationalSignificantNumber,
metadata,
NATIONAL,
carrierCode))
maybeAppendFormattedExtension(number, metadata, NATIONAL, formattedNumber)
prefixNumberWithCountryCallingCode(
countryCallingCode,
NATIONAL,
formattedNumber)
return formattedNumber.String()
} | go | func FormatNationalNumberWithCarrierCode(number *PhoneNumber, carrierCode string) string {
countryCallingCode := int(number.GetCountryCode())
nationalSignificantNumber := GetNationalSignificantNumber(number)
if !hasValidCountryCallingCode(countryCallingCode) {
return nationalSignificantNumber
}
// Note GetRegionCodeForCountryCode() is used because formatting
// information for regions which share a country calling code is
// contained by only one region for performance reasons. For
// example, for NANPA regions it will be contained in the metadata for US.
regionCode := GetRegionCodeForCountryCode(countryCallingCode)
// Metadata cannot be null because the country calling code is valid.
metadata := getMetadataForRegionOrCallingCode(countryCallingCode, regionCode)
formattedNumber := builder.NewBuilder(nil)
formattedNumber.WriteString(
formatNsnWithCarrier(
nationalSignificantNumber,
metadata,
NATIONAL,
carrierCode))
maybeAppendFormattedExtension(number, metadata, NATIONAL, formattedNumber)
prefixNumberWithCountryCallingCode(
countryCallingCode,
NATIONAL,
formattedNumber)
return formattedNumber.String()
} | [
"func",
"FormatNationalNumberWithCarrierCode",
"(",
"number",
"*",
"PhoneNumber",
",",
"carrierCode",
"string",
")",
"string",
"{",
"countryCallingCode",
":=",
"int",
"(",
"number",
".",
"GetCountryCode",
"(",
")",
")",
"\n",
"nationalSignificantNumber",
":=",
"GetN... | // Formats a phone number in national format for dialing using the carrier
// as specified in the carrierCode. The carrierCode will always be used
// regardless of whether the phone number already has a preferred domestic
// carrier code stored. If carrierCode contains an empty string, returns
// the number in national format without any carrier code. | [
"Formats",
"a",
"phone",
"number",
"in",
"national",
"format",
"for",
"dialing",
"using",
"the",
"carrier",
"as",
"specified",
"in",
"the",
"carrierCode",
".",
"The",
"carrierCode",
"will",
"always",
"be",
"used",
"regardless",
"of",
"whether",
"the",
"phone",... | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1174-L1201 |
12 | ttacon/libphonenumber | phonenumberutil.go | FormatNationalNumberWithPreferredCarrierCode | func FormatNationalNumberWithPreferredCarrierCode(
number *PhoneNumber,
fallbackCarrierCode string) string {
pref := number.GetPreferredDomesticCarrierCode()
if number.GetPreferredDomesticCarrierCode() == "" {
pref = fallbackCarrierCode
}
return FormatNationalNumberWithCarrierCode(number, pref)
} | go | func FormatNationalNumberWithPreferredCarrierCode(
number *PhoneNumber,
fallbackCarrierCode string) string {
pref := number.GetPreferredDomesticCarrierCode()
if number.GetPreferredDomesticCarrierCode() == "" {
pref = fallbackCarrierCode
}
return FormatNationalNumberWithCarrierCode(number, pref)
} | [
"func",
"FormatNationalNumberWithPreferredCarrierCode",
"(",
"number",
"*",
"PhoneNumber",
",",
"fallbackCarrierCode",
"string",
")",
"string",
"{",
"pref",
":=",
"number",
".",
"GetPreferredDomesticCarrierCode",
"(",
")",
"\n",
"if",
"number",
".",
"GetPreferredDomesti... | // Formats a phone number in national format for dialing using the carrier
// as specified in the preferredDomesticCarrierCode field of the PhoneNumber
// object passed in. If that is missing, use the fallbackCarrierCode passed
// in instead. If there is no preferredDomesticCarrierCode, and the
// fallbackCarrierCode contains an empty string, return the number in
// national format without any carrier code.
//
// Use formatNationalNumberWithCarrierCode instead if the carrier code
// passed in should take precedence over the number's
// preferredDomesticCarrierCode when formatting. | [
"Formats",
"a",
"phone",
"number",
"in",
"national",
"format",
"for",
"dialing",
"using",
"the",
"carrier",
"as",
"specified",
"in",
"the",
"preferredDomesticCarrierCode",
"field",
"of",
"the",
"PhoneNumber",
"object",
"passed",
"in",
".",
"If",
"that",
"is",
... | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1221-L1230 |
13 | ttacon/libphonenumber | phonenumberutil.go | FormatInOriginalFormat | func FormatInOriginalFormat(number *PhoneNumber, regionCallingFrom string) string {
rawInput := number.GetRawInput()
if len(rawInput) == 0 &&
(hasUnexpectedItalianLeadingZero(number) ||
!hasFormattingPatternForNumber(number)) {
// We check if we have the formatting pattern because without that, we might format the number
// as a group without national prefix.
return rawInput
}
if number.GetCountryCodeSource() == 0 {
return Format(number, NATIONAL)
}
var formattedNumber string
switch number.GetCountryCodeSource() {
case PhoneNumber_FROM_NUMBER_WITH_PLUS_SIGN:
formattedNumber = Format(number, INTERNATIONAL)
case PhoneNumber_FROM_NUMBER_WITH_IDD:
formattedNumber = FormatOutOfCountryCallingNumber(number, regionCallingFrom)
case PhoneNumber_FROM_NUMBER_WITHOUT_PLUS_SIGN:
formattedNumber = Format(number, INTERNATIONAL)[1:]
case PhoneNumber_FROM_DEFAULT_COUNTRY:
// Fall-through to default case.
fallthrough
default:
regionCode := GetRegionCodeForCountryCode(int(number.GetCountryCode()))
// We strip non-digits from the NDD here, and from the raw
// input later, so that we can compare them easily.
nationalPrefix := GetNddPrefixForRegion(
regionCode, true /* strip non-digits */)
nationalFormat := Format(number, NATIONAL)
if len(nationalPrefix) == 0 {
// If the region doesn't have a national prefix at all,
// we can safely return the national format without worrying
// about a national prefix being added.
formattedNumber = nationalFormat
break
}
// Otherwise, we check if the original number was entered with
// a national prefix.
if rawInputContainsNationalPrefix(rawInput, nationalPrefix, regionCode) {
// If so, we can safely return the national format.
formattedNumber = nationalFormat
}
// Metadata cannot be null here because GetNddPrefixForRegion()
// (above) returns null if there is no metadata for the region.
metadata := getMetadataForRegion(regionCode)
nationalNumber := GetNationalSignificantNumber(number)
formatRule :=
chooseFormattingPatternForNumber(metadata.GetNumberFormat(), nationalNumber)
// The format rule could still be null here if the national
// number was 0 and there was no raw input (this should not
// be possible for numbers generated by the phonenumber library
// as they would also not have a country calling code and we
// would have exited earlier).
if formatRule == nil {
formattedNumber = nationalFormat
break
}
// When the format we apply to this number doesn't contain
// national prefix, we can just return the national format.
// TODO: Refactor the code below with the code in
// isNationalPrefixPresentIfRequired.
candidateNationalPrefixRule := formatRule.GetNationalPrefixFormattingRule()
// We assume that the first-group symbol will never be _before_
// the national prefix.
indexOfFirstGroup := strings.Index(candidateNationalPrefixRule, "$1")
if indexOfFirstGroup <= 0 {
formattedNumber = nationalFormat
break
}
candidateNationalPrefixRule =
candidateNationalPrefixRule[0:indexOfFirstGroup]
candidateNationalPrefixRule = NormalizeDigitsOnly(candidateNationalPrefixRule)
if len(candidateNationalPrefixRule) == 0 {
// National prefix not used when formatting this number.
formattedNumber = nationalFormat
break
}
// Otherwise, we need to remove the national prefix from our output.
var numFormatCopy *NumberFormat
proto.Merge(numFormatCopy, formatRule)
numFormatCopy.NationalPrefixFormattingRule = nil
var numberFormats = []*NumberFormat{numFormatCopy}
formattedNumber = FormatByPattern(number, NATIONAL, numberFormats)
break
}
rawInput = number.GetRawInput()
// If no digit is inserted/removed/modified as a result of our
// formatting, we return the formatted phone number; otherwise we
// return the raw input the user entered.
if len(formattedNumber) != 0 && len(rawInput) > 0 {
normalizedFormattedNumber := normalizeDiallableCharsOnly(formattedNumber)
normalizedRawInput := normalizeDiallableCharsOnly(rawInput)
if normalizedFormattedNumber != normalizedRawInput {
formattedNumber = rawInput
}
}
return formattedNumber
} | go | func FormatInOriginalFormat(number *PhoneNumber, regionCallingFrom string) string {
rawInput := number.GetRawInput()
if len(rawInput) == 0 &&
(hasUnexpectedItalianLeadingZero(number) ||
!hasFormattingPatternForNumber(number)) {
// We check if we have the formatting pattern because without that, we might format the number
// as a group without national prefix.
return rawInput
}
if number.GetCountryCodeSource() == 0 {
return Format(number, NATIONAL)
}
var formattedNumber string
switch number.GetCountryCodeSource() {
case PhoneNumber_FROM_NUMBER_WITH_PLUS_SIGN:
formattedNumber = Format(number, INTERNATIONAL)
case PhoneNumber_FROM_NUMBER_WITH_IDD:
formattedNumber = FormatOutOfCountryCallingNumber(number, regionCallingFrom)
case PhoneNumber_FROM_NUMBER_WITHOUT_PLUS_SIGN:
formattedNumber = Format(number, INTERNATIONAL)[1:]
case PhoneNumber_FROM_DEFAULT_COUNTRY:
// Fall-through to default case.
fallthrough
default:
regionCode := GetRegionCodeForCountryCode(int(number.GetCountryCode()))
// We strip non-digits from the NDD here, and from the raw
// input later, so that we can compare them easily.
nationalPrefix := GetNddPrefixForRegion(
regionCode, true /* strip non-digits */)
nationalFormat := Format(number, NATIONAL)
if len(nationalPrefix) == 0 {
// If the region doesn't have a national prefix at all,
// we can safely return the national format without worrying
// about a national prefix being added.
formattedNumber = nationalFormat
break
}
// Otherwise, we check if the original number was entered with
// a national prefix.
if rawInputContainsNationalPrefix(rawInput, nationalPrefix, regionCode) {
// If so, we can safely return the national format.
formattedNumber = nationalFormat
}
// Metadata cannot be null here because GetNddPrefixForRegion()
// (above) returns null if there is no metadata for the region.
metadata := getMetadataForRegion(regionCode)
nationalNumber := GetNationalSignificantNumber(number)
formatRule :=
chooseFormattingPatternForNumber(metadata.GetNumberFormat(), nationalNumber)
// The format rule could still be null here if the national
// number was 0 and there was no raw input (this should not
// be possible for numbers generated by the phonenumber library
// as they would also not have a country calling code and we
// would have exited earlier).
if formatRule == nil {
formattedNumber = nationalFormat
break
}
// When the format we apply to this number doesn't contain
// national prefix, we can just return the national format.
// TODO: Refactor the code below with the code in
// isNationalPrefixPresentIfRequired.
candidateNationalPrefixRule := formatRule.GetNationalPrefixFormattingRule()
// We assume that the first-group symbol will never be _before_
// the national prefix.
indexOfFirstGroup := strings.Index(candidateNationalPrefixRule, "$1")
if indexOfFirstGroup <= 0 {
formattedNumber = nationalFormat
break
}
candidateNationalPrefixRule =
candidateNationalPrefixRule[0:indexOfFirstGroup]
candidateNationalPrefixRule = NormalizeDigitsOnly(candidateNationalPrefixRule)
if len(candidateNationalPrefixRule) == 0 {
// National prefix not used when formatting this number.
formattedNumber = nationalFormat
break
}
// Otherwise, we need to remove the national prefix from our output.
var numFormatCopy *NumberFormat
proto.Merge(numFormatCopy, formatRule)
numFormatCopy.NationalPrefixFormattingRule = nil
var numberFormats = []*NumberFormat{numFormatCopy}
formattedNumber = FormatByPattern(number, NATIONAL, numberFormats)
break
}
rawInput = number.GetRawInput()
// If no digit is inserted/removed/modified as a result of our
// formatting, we return the formatted phone number; otherwise we
// return the raw input the user entered.
if len(formattedNumber) != 0 && len(rawInput) > 0 {
normalizedFormattedNumber := normalizeDiallableCharsOnly(formattedNumber)
normalizedRawInput := normalizeDiallableCharsOnly(rawInput)
if normalizedFormattedNumber != normalizedRawInput {
formattedNumber = rawInput
}
}
return formattedNumber
} | [
"func",
"FormatInOriginalFormat",
"(",
"number",
"*",
"PhoneNumber",
",",
"regionCallingFrom",
"string",
")",
"string",
"{",
"rawInput",
":=",
"number",
".",
"GetRawInput",
"(",
")",
"\n",
"if",
"len",
"(",
"rawInput",
")",
"==",
"0",
"&&",
"(",
"hasUnexpect... | // Formats a phone number using the original phone number format that the
// number is parsed from. The original format is embedded in the
// country_code_source field of the PhoneNumber object passed in. If such
// information is missing, the number will be formatted into the NATIONAL
// format by default. When the number contains a leading zero and this is
// unexpected for this country, or we don't have a formatting pattern for
// the number, the method returns the raw input when it is available.
//
// Note this method guarantees no digit will be inserted, removed or
// modified as a result of formatting. | [
"Formats",
"a",
"phone",
"number",
"using",
"the",
"original",
"phone",
"number",
"format",
"that",
"the",
"number",
"is",
"parsed",
"from",
".",
"The",
"original",
"format",
"is",
"embedded",
"in",
"the",
"country_code_source",
"field",
"of",
"the",
"PhoneNum... | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1444-L1542 |
14 | ttacon/libphonenumber | phonenumberutil.go | rawInputContainsNationalPrefix | func rawInputContainsNationalPrefix(rawInput, nationalPrefix, regionCode string) bool {
normalizedNationalNumber := NormalizeDigitsOnly(rawInput)
if strings.HasPrefix(normalizedNationalNumber, nationalPrefix) {
// Some Japanese numbers (e.g. 00777123) might be mistaken to
// contain the national prefix when written without it
// (e.g. 0777123) if we just do prefix matching. To tackle that,
// we check the validity of the number if the assumed national
// prefix is removed (777123 won't be valid in Japan).
num, err := Parse(normalizedNationalNumber[len(nationalPrefix):], regionCode)
if err != nil {
return false
}
return IsValidNumber(num)
}
return false
} | go | func rawInputContainsNationalPrefix(rawInput, nationalPrefix, regionCode string) bool {
normalizedNationalNumber := NormalizeDigitsOnly(rawInput)
if strings.HasPrefix(normalizedNationalNumber, nationalPrefix) {
// Some Japanese numbers (e.g. 00777123) might be mistaken to
// contain the national prefix when written without it
// (e.g. 0777123) if we just do prefix matching. To tackle that,
// we check the validity of the number if the assumed national
// prefix is removed (777123 won't be valid in Japan).
num, err := Parse(normalizedNationalNumber[len(nationalPrefix):], regionCode)
if err != nil {
return false
}
return IsValidNumber(num)
}
return false
} | [
"func",
"rawInputContainsNationalPrefix",
"(",
"rawInput",
",",
"nationalPrefix",
",",
"regionCode",
"string",
")",
"bool",
"{",
"normalizedNationalNumber",
":=",
"NormalizeDigitsOnly",
"(",
"rawInput",
")",
"\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"normalizedNat... | // Check if rawInput, which is assumed to be in the national format, has
// a national prefix. The national prefix is assumed to be in digits-only
// form. | [
"Check",
"if",
"rawInput",
"which",
"is",
"assumed",
"to",
"be",
"in",
"the",
"national",
"format",
"has",
"a",
"national",
"prefix",
".",
"The",
"national",
"prefix",
"is",
"assumed",
"to",
"be",
"in",
"digits",
"-",
"only",
"form",
"."
] | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1547-L1563 |
15 | ttacon/libphonenumber | phonenumberutil.go | hasUnexpectedItalianLeadingZero | func hasUnexpectedItalianLeadingZero(number *PhoneNumber) bool {
return number.GetItalianLeadingZero() &&
!isLeadingZeroPossible(int(number.GetCountryCode()))
} | go | func hasUnexpectedItalianLeadingZero(number *PhoneNumber) bool {
return number.GetItalianLeadingZero() &&
!isLeadingZeroPossible(int(number.GetCountryCode()))
} | [
"func",
"hasUnexpectedItalianLeadingZero",
"(",
"number",
"*",
"PhoneNumber",
")",
"bool",
"{",
"return",
"number",
".",
"GetItalianLeadingZero",
"(",
")",
"&&",
"!",
"isLeadingZeroPossible",
"(",
"int",
"(",
"number",
".",
"GetCountryCode",
"(",
")",
")",
")",
... | // Returns true if a number is from a region whose national significant
// number couldn't contain a leading zero, but has the italian_leading_zero
// field set to true. | [
"Returns",
"true",
"if",
"a",
"number",
"is",
"from",
"a",
"region",
"whose",
"national",
"significant",
"number",
"couldn",
"t",
"contain",
"a",
"leading",
"zero",
"but",
"has",
"the",
"italian_leading_zero",
"field",
"set",
"to",
"true",
"."
] | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1568-L1571 |
16 | ttacon/libphonenumber | phonenumberutil.go | GetNationalSignificantNumber | func GetNationalSignificantNumber(number *PhoneNumber) string {
// If leading zero(s) have been set, we prefix this now. Note this
// is not a national prefix.
nationalNumber := builder.NewBuilder(nil)
if number.GetItalianLeadingZero() {
zeros := make([]byte, number.GetNumberOfLeadingZeros())
for i := range zeros {
zeros[i] = '0'
}
nationalNumber.Write(zeros)
}
asStr := strconv.FormatUint(number.GetNationalNumber(), 10)
nationalNumber.WriteString(asStr)
return nationalNumber.String()
} | go | func GetNationalSignificantNumber(number *PhoneNumber) string {
// If leading zero(s) have been set, we prefix this now. Note this
// is not a national prefix.
nationalNumber := builder.NewBuilder(nil)
if number.GetItalianLeadingZero() {
zeros := make([]byte, number.GetNumberOfLeadingZeros())
for i := range zeros {
zeros[i] = '0'
}
nationalNumber.Write(zeros)
}
asStr := strconv.FormatUint(number.GetNationalNumber(), 10)
nationalNumber.WriteString(asStr)
return nationalNumber.String()
} | [
"func",
"GetNationalSignificantNumber",
"(",
"number",
"*",
"PhoneNumber",
")",
"string",
"{",
"// If leading zero(s) have been set, we prefix this now. Note this",
"// is not a national prefix.",
"nationalNumber",
":=",
"builder",
".",
"NewBuilder",
"(",
"nil",
")",
"\n",
"i... | // Gets the national significant number of the a phone number. Note a
// national significant number doesn't contain a national prefix or
// any formatting. | [
"Gets",
"the",
"national",
"significant",
"number",
"of",
"the",
"a",
"phone",
"number",
".",
"Note",
"a",
"national",
"significant",
"number",
"doesn",
"t",
"contain",
"a",
"national",
"prefix",
"or",
"any",
"formatting",
"."
] | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1718-L1733 |
17 | ttacon/libphonenumber | phonenumberutil.go | prefixNumberWithCountryCallingCode | func prefixNumberWithCountryCallingCode(
countryCallingCode int,
numberFormat PhoneNumberFormat,
formattedNumber *builder.Builder) {
// TODO(ttacon): add some sort of BulkWrite builder to builder.Builder
// also that name isn't too awesome...:)
newBuf := builder.NewBuilder(nil)
switch numberFormat {
case E164:
newBuf.WriteString(string(PLUS_SIGN))
newBuf.Write(strconv.AppendInt([]byte{}, int64(countryCallingCode), 10))
newBuf.Write(formattedNumber.Bytes())
case INTERNATIONAL:
newBuf.WriteString(string(PLUS_SIGN))
newBuf.Write(strconv.AppendInt([]byte{}, int64(countryCallingCode), 10))
newBuf.WriteString(" ")
newBuf.Write(formattedNumber.Bytes())
case RFC3966:
newBuf.WriteString(RFC3966_PREFIX)
newBuf.WriteString(string(PLUS_SIGN))
newBuf.Write(strconv.AppendInt([]byte{}, int64(countryCallingCode), 10))
newBuf.WriteString("-")
newBuf.Write(formattedNumber.Bytes())
case NATIONAL:
fallthrough
default:
newBuf.Write(formattedNumber.Bytes())
}
formattedNumber.ResetWith(newBuf.Bytes())
} | go | func prefixNumberWithCountryCallingCode(
countryCallingCode int,
numberFormat PhoneNumberFormat,
formattedNumber *builder.Builder) {
// TODO(ttacon): add some sort of BulkWrite builder to builder.Builder
// also that name isn't too awesome...:)
newBuf := builder.NewBuilder(nil)
switch numberFormat {
case E164:
newBuf.WriteString(string(PLUS_SIGN))
newBuf.Write(strconv.AppendInt([]byte{}, int64(countryCallingCode), 10))
newBuf.Write(formattedNumber.Bytes())
case INTERNATIONAL:
newBuf.WriteString(string(PLUS_SIGN))
newBuf.Write(strconv.AppendInt([]byte{}, int64(countryCallingCode), 10))
newBuf.WriteString(" ")
newBuf.Write(formattedNumber.Bytes())
case RFC3966:
newBuf.WriteString(RFC3966_PREFIX)
newBuf.WriteString(string(PLUS_SIGN))
newBuf.Write(strconv.AppendInt([]byte{}, int64(countryCallingCode), 10))
newBuf.WriteString("-")
newBuf.Write(formattedNumber.Bytes())
case NATIONAL:
fallthrough
default:
newBuf.Write(formattedNumber.Bytes())
}
formattedNumber.ResetWith(newBuf.Bytes())
} | [
"func",
"prefixNumberWithCountryCallingCode",
"(",
"countryCallingCode",
"int",
",",
"numberFormat",
"PhoneNumberFormat",
",",
"formattedNumber",
"*",
"builder",
".",
"Builder",
")",
"{",
"// TODO(ttacon): add some sort of BulkWrite builder to builder.Builder",
"// also that name i... | // A helper function that is used by format and formatByPattern. | [
"A",
"helper",
"function",
"that",
"is",
"used",
"by",
"format",
"and",
"formatByPattern",
"."
] | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1736-L1766 |
18 | ttacon/libphonenumber | phonenumberutil.go | formatNsn | func formatNsn(
number string, metadata *PhoneMetadata, numberFormat PhoneNumberFormat) string {
return formatNsnWithCarrier(number, metadata, numberFormat, "")
} | go | func formatNsn(
number string, metadata *PhoneMetadata, numberFormat PhoneNumberFormat) string {
return formatNsnWithCarrier(number, metadata, numberFormat, "")
} | [
"func",
"formatNsn",
"(",
"number",
"string",
",",
"metadata",
"*",
"PhoneMetadata",
",",
"numberFormat",
"PhoneNumberFormat",
")",
"string",
"{",
"return",
"formatNsnWithCarrier",
"(",
"number",
",",
"metadata",
",",
"numberFormat",
",",
"\"",
"\"",
")",
"\n",
... | // Simple wrapper of formatNsn for the common case of no carrier code. | [
"Simple",
"wrapper",
"of",
"formatNsn",
"for",
"the",
"common",
"case",
"of",
"no",
"carrier",
"code",
"."
] | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1769-L1772 |
19 | ttacon/libphonenumber | phonenumberutil.go | formatNsnUsingPattern | func formatNsnUsingPattern(
nationalNumber string,
formattingPattern *NumberFormat,
numberFormat PhoneNumberFormat) string {
return formatNsnUsingPatternWithCarrier(
nationalNumber, formattingPattern, numberFormat, "")
} | go | func formatNsnUsingPattern(
nationalNumber string,
formattingPattern *NumberFormat,
numberFormat PhoneNumberFormat) string {
return formatNsnUsingPatternWithCarrier(
nationalNumber, formattingPattern, numberFormat, "")
} | [
"func",
"formatNsnUsingPattern",
"(",
"nationalNumber",
"string",
",",
"formattingPattern",
"*",
"NumberFormat",
",",
"numberFormat",
"PhoneNumberFormat",
")",
"string",
"{",
"return",
"formatNsnUsingPatternWithCarrier",
"(",
"nationalNumber",
",",
"formattingPattern",
",",... | // Simple wrapper of formatNsnUsingPattern for the common case of no carrier code. | [
"Simple",
"wrapper",
"of",
"formatNsnUsingPattern",
"for",
"the",
"common",
"case",
"of",
"no",
"carrier",
"code",
"."
] | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1844-L1850 |
20 | ttacon/libphonenumber | phonenumberutil.go | formatNsnUsingPatternWithCarrier | func formatNsnUsingPatternWithCarrier(
nationalNumber string,
formattingPattern *NumberFormat,
numberFormat PhoneNumberFormat,
carrierCode string) string {
numberFormatRule := formattingPattern.GetFormat()
m, ok := readFromRegexCache(formattingPattern.GetPattern())
if !ok {
pat := formattingPattern.GetPattern()
m = regexp.MustCompile(pat)
writeToRegexCache(pat, m)
}
formattedNationalNumber := ""
if numberFormat == NATIONAL &&
len(carrierCode) > 0 &&
len(formattingPattern.GetDomesticCarrierCodeFormattingRule()) > 0 {
// Replace the $CC in the formatting rule with the desired carrier code.
carrierCodeFormattingRule := formattingPattern.GetDomesticCarrierCodeFormattingRule()
i := 1
carrierCodeFormattingRule =
CC_PATTERN.ReplaceAllStringFunc(carrierCodeFormattingRule,
func(s string) string {
if i > 0 {
i -= 1
return carrierCode
}
return s
})
// Now replace the $FG in the formatting rule with the first group
// and the carrier code combined in the appropriate way.
i = 1
numberFormatRule = FIRST_GROUP_PATTERN.ReplaceAllStringFunc(
numberFormatRule,
func(s string) string {
if i > 0 {
i -= 1
return carrierCodeFormattingRule
}
return s
})
formattedNationalNumber = m.ReplaceAllString(numberFormatRule, nationalNumber)
} else {
// Use the national prefix formatting rule instead.
nationalPrefixFormattingRule :=
formattingPattern.GetNationalPrefixFormattingRule()
if numberFormat == NATIONAL &&
len(nationalPrefixFormattingRule) > 0 {
i := 1
fgp := FIRST_GROUP_PATTERN.ReplaceAllStringFunc(numberFormatRule,
func(s string) string {
if i > 0 {
i -= 1
return nationalPrefixFormattingRule
}
return s
})
formattedNationalNumber = m.ReplaceAllString(nationalNumber, fgp)
} else {
formattedNationalNumber = m.ReplaceAllString(
nationalNumber,
numberFormatRule,
)
}
}
if numberFormat == RFC3966 {
// Strip any leading punctuation.
inds := SEPARATOR_PATTERN.FindStringIndex(formattedNationalNumber)
if len(inds) > 0 && inds[0] == 0 {
formattedNationalNumber = formattedNationalNumber[inds[1]:]
}
allStr := NOT_SEPARATOR_PATTERN.FindAllString(formattedNationalNumber, -1)
formattedNationalNumber = strings.Join(allStr, "-")
}
return formattedNationalNumber
} | go | func formatNsnUsingPatternWithCarrier(
nationalNumber string,
formattingPattern *NumberFormat,
numberFormat PhoneNumberFormat,
carrierCode string) string {
numberFormatRule := formattingPattern.GetFormat()
m, ok := readFromRegexCache(formattingPattern.GetPattern())
if !ok {
pat := formattingPattern.GetPattern()
m = regexp.MustCompile(pat)
writeToRegexCache(pat, m)
}
formattedNationalNumber := ""
if numberFormat == NATIONAL &&
len(carrierCode) > 0 &&
len(formattingPattern.GetDomesticCarrierCodeFormattingRule()) > 0 {
// Replace the $CC in the formatting rule with the desired carrier code.
carrierCodeFormattingRule := formattingPattern.GetDomesticCarrierCodeFormattingRule()
i := 1
carrierCodeFormattingRule =
CC_PATTERN.ReplaceAllStringFunc(carrierCodeFormattingRule,
func(s string) string {
if i > 0 {
i -= 1
return carrierCode
}
return s
})
// Now replace the $FG in the formatting rule with the first group
// and the carrier code combined in the appropriate way.
i = 1
numberFormatRule = FIRST_GROUP_PATTERN.ReplaceAllStringFunc(
numberFormatRule,
func(s string) string {
if i > 0 {
i -= 1
return carrierCodeFormattingRule
}
return s
})
formattedNationalNumber = m.ReplaceAllString(numberFormatRule, nationalNumber)
} else {
// Use the national prefix formatting rule instead.
nationalPrefixFormattingRule :=
formattingPattern.GetNationalPrefixFormattingRule()
if numberFormat == NATIONAL &&
len(nationalPrefixFormattingRule) > 0 {
i := 1
fgp := FIRST_GROUP_PATTERN.ReplaceAllStringFunc(numberFormatRule,
func(s string) string {
if i > 0 {
i -= 1
return nationalPrefixFormattingRule
}
return s
})
formattedNationalNumber = m.ReplaceAllString(nationalNumber, fgp)
} else {
formattedNationalNumber = m.ReplaceAllString(
nationalNumber,
numberFormatRule,
)
}
}
if numberFormat == RFC3966 {
// Strip any leading punctuation.
inds := SEPARATOR_PATTERN.FindStringIndex(formattedNationalNumber)
if len(inds) > 0 && inds[0] == 0 {
formattedNationalNumber = formattedNationalNumber[inds[1]:]
}
allStr := NOT_SEPARATOR_PATTERN.FindAllString(formattedNationalNumber, -1)
formattedNationalNumber = strings.Join(allStr, "-")
}
return formattedNationalNumber
} | [
"func",
"formatNsnUsingPatternWithCarrier",
"(",
"nationalNumber",
"string",
",",
"formattingPattern",
"*",
"NumberFormat",
",",
"numberFormat",
"PhoneNumberFormat",
",",
"carrierCode",
"string",
")",
"string",
"{",
"numberFormatRule",
":=",
"formattingPattern",
".",
"Get... | // Note that carrierCode is optional - if null or an empty string, no
// carrier code replacement will take place. | [
"Note",
"that",
"carrierCode",
"is",
"optional",
"-",
"if",
"null",
"or",
"an",
"empty",
"string",
"no",
"carrier",
"code",
"replacement",
"will",
"take",
"place",
"."
] | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1854-L1930 |
21 | ttacon/libphonenumber | phonenumberutil.go | GetExampleNumberForType | func GetExampleNumberForType(regionCode string, typ PhoneNumberType) *PhoneNumber {
// Check the region code is valid.
if !isValidRegionCode(regionCode) {
return nil
}
//PhoneNumberDesc (pointer?)
var desc = getNumberDescByType(getMetadataForRegion(regionCode), typ)
exNum := desc.GetExampleNumber()
if len(exNum) > 0 {
num, err := Parse(exNum, regionCode)
if err != nil {
return nil
}
return num
}
return nil
} | go | func GetExampleNumberForType(regionCode string, typ PhoneNumberType) *PhoneNumber {
// Check the region code is valid.
if !isValidRegionCode(regionCode) {
return nil
}
//PhoneNumberDesc (pointer?)
var desc = getNumberDescByType(getMetadataForRegion(regionCode), typ)
exNum := desc.GetExampleNumber()
if len(exNum) > 0 {
num, err := Parse(exNum, regionCode)
if err != nil {
return nil
}
return num
}
return nil
} | [
"func",
"GetExampleNumberForType",
"(",
"regionCode",
"string",
",",
"typ",
"PhoneNumberType",
")",
"*",
"PhoneNumber",
"{",
"// Check the region code is valid.",
"if",
"!",
"isValidRegionCode",
"(",
"regionCode",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"//Phone... | // Gets a valid number for the specified region and number type. | [
"Gets",
"a",
"valid",
"number",
"for",
"the",
"specified",
"region",
"and",
"number",
"type",
"."
] | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1938-L1954 |
22 | ttacon/libphonenumber | phonenumberutil.go | GetExampleNumberForNonGeoEntity | func GetExampleNumberForNonGeoEntity(countryCallingCode int) *PhoneNumber {
var metadata *PhoneMetadata = getMetadataForNonGeographicalRegion(countryCallingCode)
if metadata == nil {
return nil
}
var desc *PhoneNumberDesc = metadata.GetTollFree()
if countryCallingCode == 979 {
desc = metadata.GetPremiumRate()
}
exNum := desc.GetExampleNumber()
if len(exNum) > 0 {
num, err := Parse("+"+strconv.Itoa(countryCallingCode)+exNum, "ZZ")
if err != nil {
return nil
}
return num
}
return nil
} | go | func GetExampleNumberForNonGeoEntity(countryCallingCode int) *PhoneNumber {
var metadata *PhoneMetadata = getMetadataForNonGeographicalRegion(countryCallingCode)
if metadata == nil {
return nil
}
var desc *PhoneNumberDesc = metadata.GetTollFree()
if countryCallingCode == 979 {
desc = metadata.GetPremiumRate()
}
exNum := desc.GetExampleNumber()
if len(exNum) > 0 {
num, err := Parse("+"+strconv.Itoa(countryCallingCode)+exNum, "ZZ")
if err != nil {
return nil
}
return num
}
return nil
} | [
"func",
"GetExampleNumberForNonGeoEntity",
"(",
"countryCallingCode",
"int",
")",
"*",
"PhoneNumber",
"{",
"var",
"metadata",
"*",
"PhoneMetadata",
"=",
"getMetadataForNonGeographicalRegion",
"(",
"countryCallingCode",
")",
"\n",
"if",
"metadata",
"==",
"nil",
"{",
"r... | // Gets a valid number for the specified country calling code for a
// non-geographical entity. | [
"Gets",
"a",
"valid",
"number",
"for",
"the",
"specified",
"country",
"calling",
"code",
"for",
"a",
"non",
"-",
"geographical",
"entity",
"."
] | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1958-L1978 |
23 | ttacon/libphonenumber | phonenumberutil.go | maybeAppendFormattedExtension | func maybeAppendFormattedExtension(
number *PhoneNumber,
metadata *PhoneMetadata,
numberFormat PhoneNumberFormat,
formattedNumber *builder.Builder) {
extension := number.GetExtension()
if len(extension) == 0 {
return
}
prefExtn := metadata.GetPreferredExtnPrefix()
if numberFormat == RFC3966 {
formattedNumber.WriteString(RFC3966_EXTN_PREFIX)
} else if len(prefExtn) > 0 {
formattedNumber.WriteString(prefExtn)
} else {
formattedNumber.WriteString(DEFAULT_EXTN_PREFIX)
}
formattedNumber.WriteString(extension)
} | go | func maybeAppendFormattedExtension(
number *PhoneNumber,
metadata *PhoneMetadata,
numberFormat PhoneNumberFormat,
formattedNumber *builder.Builder) {
extension := number.GetExtension()
if len(extension) == 0 {
return
}
prefExtn := metadata.GetPreferredExtnPrefix()
if numberFormat == RFC3966 {
formattedNumber.WriteString(RFC3966_EXTN_PREFIX)
} else if len(prefExtn) > 0 {
formattedNumber.WriteString(prefExtn)
} else {
formattedNumber.WriteString(DEFAULT_EXTN_PREFIX)
}
formattedNumber.WriteString(extension)
} | [
"func",
"maybeAppendFormattedExtension",
"(",
"number",
"*",
"PhoneNumber",
",",
"metadata",
"*",
"PhoneMetadata",
",",
"numberFormat",
"PhoneNumberFormat",
",",
"formattedNumber",
"*",
"builder",
".",
"Builder",
")",
"{",
"extension",
":=",
"number",
".",
"GetExten... | // Appends the formatted extension of a phone number to formattedNumber,
// if the phone number had an extension specified. | [
"Appends",
"the",
"formatted",
"extension",
"of",
"a",
"phone",
"number",
"to",
"formattedNumber",
"if",
"the",
"phone",
"number",
"had",
"an",
"extension",
"specified",
"."
] | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L1982-L2002 |
24 | ttacon/libphonenumber | phonenumberutil.go | GetNumberType | func GetNumberType(number *PhoneNumber) PhoneNumberType {
var regionCode string = GetRegionCodeForNumber(number)
var metadata *PhoneMetadata = getMetadataForRegionOrCallingCode(
int(number.GetCountryCode()), regionCode)
if metadata == nil {
return UNKNOWN
}
var nationalSignificantNumber = GetNationalSignificantNumber(number)
return getNumberTypeHelper(nationalSignificantNumber, metadata)
} | go | func GetNumberType(number *PhoneNumber) PhoneNumberType {
var regionCode string = GetRegionCodeForNumber(number)
var metadata *PhoneMetadata = getMetadataForRegionOrCallingCode(
int(number.GetCountryCode()), regionCode)
if metadata == nil {
return UNKNOWN
}
var nationalSignificantNumber = GetNationalSignificantNumber(number)
return getNumberTypeHelper(nationalSignificantNumber, metadata)
} | [
"func",
"GetNumberType",
"(",
"number",
"*",
"PhoneNumber",
")",
"PhoneNumberType",
"{",
"var",
"regionCode",
"string",
"=",
"GetRegionCodeForNumber",
"(",
"number",
")",
"\n",
"var",
"metadata",
"*",
"PhoneMetadata",
"=",
"getMetadataForRegionOrCallingCode",
"(",
"... | // Gets the type of a phone number. | [
"Gets",
"the",
"type",
"of",
"a",
"phone",
"number",
"."
] | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L2037-L2046 |
25 | ttacon/libphonenumber | phonenumberutil.go | getMetadataForRegion | func getMetadataForRegion(regionCode string) *PhoneMetadata {
if !isValidRegionCode(regionCode) {
return nil
}
val, _ := readFromRegionToMetadataMap(regionCode)
return val
} | go | func getMetadataForRegion(regionCode string) *PhoneMetadata {
if !isValidRegionCode(regionCode) {
return nil
}
val, _ := readFromRegionToMetadataMap(regionCode)
return val
} | [
"func",
"getMetadataForRegion",
"(",
"regionCode",
"string",
")",
"*",
"PhoneMetadata",
"{",
"if",
"!",
"isValidRegionCode",
"(",
"regionCode",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"val",
",",
"_",
":=",
"readFromRegionToMetadataMap",
"(",
"regionCode",
... | // Returns the metadata for the given region code or nil if the region
// code is invalid or unknown. | [
"Returns",
"the",
"metadata",
"for",
"the",
"given",
"region",
"code",
"or",
"nil",
"if",
"the",
"region",
"code",
"is",
"invalid",
"or",
"unknown",
"."
] | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L2106-L2112 |
26 | ttacon/libphonenumber | phonenumberutil.go | IsValidNumber | func IsValidNumber(number *PhoneNumber) bool {
var regionCode string = GetRegionCodeForNumber(number)
return IsValidNumberForRegion(number, regionCode)
} | go | func IsValidNumber(number *PhoneNumber) bool {
var regionCode string = GetRegionCodeForNumber(number)
return IsValidNumberForRegion(number, regionCode)
} | [
"func",
"IsValidNumber",
"(",
"number",
"*",
"PhoneNumber",
")",
"bool",
"{",
"var",
"regionCode",
"string",
"=",
"GetRegionCodeForNumber",
"(",
"number",
")",
"\n",
"return",
"IsValidNumberForRegion",
"(",
"number",
",",
"regionCode",
")",
"\n",
"}"
] | // Tests whether a phone number matches a valid pattern. Note this doesn't
// verify the number is actually in use, which is impossible to tell by
// just looking at a number itself. | [
"Tests",
"whether",
"a",
"phone",
"number",
"matches",
"a",
"valid",
"pattern",
".",
"Note",
"this",
"doesn",
"t",
"verify",
"the",
"number",
"is",
"actually",
"in",
"use",
"which",
"is",
"impossible",
"to",
"tell",
"by",
"just",
"looking",
"at",
"a",
"n... | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L2154-L2157 |
27 | ttacon/libphonenumber | phonenumberutil.go | GetRegionCodeForNumber | func GetRegionCodeForNumber(number *PhoneNumber) string {
var countryCode int = int(number.GetCountryCode())
var regions []string = CountryCodeToRegion[countryCode]
if len(regions) == 0 {
return ""
}
if len(regions) == 1 {
return regions[0]
}
return getRegionCodeForNumberFromRegionList(number, regions)
} | go | func GetRegionCodeForNumber(number *PhoneNumber) string {
var countryCode int = int(number.GetCountryCode())
var regions []string = CountryCodeToRegion[countryCode]
if len(regions) == 0 {
return ""
}
if len(regions) == 1 {
return regions[0]
}
return getRegionCodeForNumberFromRegionList(number, regions)
} | [
"func",
"GetRegionCodeForNumber",
"(",
"number",
"*",
"PhoneNumber",
")",
"string",
"{",
"var",
"countryCode",
"int",
"=",
"int",
"(",
"number",
".",
"GetCountryCode",
"(",
")",
")",
"\n",
"var",
"regions",
"[",
"]",
"string",
"=",
"CountryCodeToRegion",
"["... | // Returns the region where a phone number is from. This could be used for
// geocoding at the region level. | [
"Returns",
"the",
"region",
"where",
"a",
"phone",
"number",
"is",
"from",
".",
"This",
"could",
"be",
"used",
"for",
"geocoding",
"at",
"the",
"region",
"level",
"."
] | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L2198-L2208 |
28 | ttacon/libphonenumber | phonenumberutil.go | getCountryCodeForValidRegion | func getCountryCodeForValidRegion(regionCode string) int {
var metadata *PhoneMetadata = getMetadataForRegion(regionCode)
return int(metadata.GetCountryCode())
} | go | func getCountryCodeForValidRegion(regionCode string) int {
var metadata *PhoneMetadata = getMetadataForRegion(regionCode)
return int(metadata.GetCountryCode())
} | [
"func",
"getCountryCodeForValidRegion",
"(",
"regionCode",
"string",
")",
"int",
"{",
"var",
"metadata",
"*",
"PhoneMetadata",
"=",
"getMetadataForRegion",
"(",
"regionCode",
")",
"\n",
"return",
"int",
"(",
"metadata",
".",
"GetCountryCode",
"(",
")",
")",
"\n"... | // Returns the country calling code for a specific region. For example,
// this would be 1 for the United States, and 64 for New Zealand. Assumes
// the region is already valid. | [
"Returns",
"the",
"country",
"calling",
"code",
"for",
"a",
"specific",
"region",
".",
"For",
"example",
"this",
"would",
"be",
"1",
"for",
"the",
"United",
"States",
"and",
"64",
"for",
"New",
"Zealand",
".",
"Assumes",
"the",
"region",
"is",
"already",
... | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L2274-L2277 |
29 | ttacon/libphonenumber | phonenumberutil.go | isLeadingZeroPossible | func isLeadingZeroPossible(countryCallingCode int) bool {
var mainMetadataForCallingCode *PhoneMetadata = getMetadataForRegionOrCallingCode(
countryCallingCode,
GetRegionCodeForCountryCode(countryCallingCode),
)
return mainMetadataForCallingCode.GetLeadingZeroPossible()
} | go | func isLeadingZeroPossible(countryCallingCode int) bool {
var mainMetadataForCallingCode *PhoneMetadata = getMetadataForRegionOrCallingCode(
countryCallingCode,
GetRegionCodeForCountryCode(countryCallingCode),
)
return mainMetadataForCallingCode.GetLeadingZeroPossible()
} | [
"func",
"isLeadingZeroPossible",
"(",
"countryCallingCode",
"int",
")",
"bool",
"{",
"var",
"mainMetadataForCallingCode",
"*",
"PhoneMetadata",
"=",
"getMetadataForRegionOrCallingCode",
"(",
"countryCallingCode",
",",
"GetRegionCodeForCountryCode",
"(",
"countryCallingCode",
... | // Checks whether the country calling code is from a region whose national
// significant number could contain a leading zero. An example of such a
// region is Italy. Returns false if no metadata for the country is found. | [
"Checks",
"whether",
"the",
"country",
"calling",
"code",
"is",
"from",
"a",
"region",
"whose",
"national",
"significant",
"number",
"could",
"contain",
"a",
"leading",
"zero",
".",
"An",
"example",
"of",
"such",
"a",
"region",
"is",
"Italy",
".",
"Returns",... | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L2317-L2323 |
30 | ttacon/libphonenumber | phonenumberutil.go | isShorterThanPossibleNormalNumber | func isShorterThanPossibleNormalNumber(
regionMetadata *PhoneMetadata,
number string) bool {
pat, ok := readFromRegexCache(regionMetadata.GetGeneralDesc().GetNationalNumberPattern())
if !ok {
patP := regionMetadata.GetGeneralDesc().GetNationalNumberPattern()
pat = regexp.MustCompile(patP)
writeToRegexCache(patP, pat)
}
return testNumberLengthAgainstPattern(pat, number) == TOO_SHORT
} | go | func isShorterThanPossibleNormalNumber(
regionMetadata *PhoneMetadata,
number string) bool {
pat, ok := readFromRegexCache(regionMetadata.GetGeneralDesc().GetNationalNumberPattern())
if !ok {
patP := regionMetadata.GetGeneralDesc().GetNationalNumberPattern()
pat = regexp.MustCompile(patP)
writeToRegexCache(patP, pat)
}
return testNumberLengthAgainstPattern(pat, number) == TOO_SHORT
} | [
"func",
"isShorterThanPossibleNormalNumber",
"(",
"regionMetadata",
"*",
"PhoneMetadata",
",",
"number",
"string",
")",
"bool",
"{",
"pat",
",",
"ok",
":=",
"readFromRegexCache",
"(",
"regionMetadata",
".",
"GetGeneralDesc",
"(",
")",
".",
"GetNationalNumberPattern",
... | // Helper method to check whether a number is too short to be a regular
// length phone number in a region. | [
"Helper",
"method",
"to",
"check",
"whether",
"a",
"number",
"is",
"too",
"short",
"to",
"be",
"a",
"regular",
"length",
"phone",
"number",
"in",
"a",
"region",
"."
] | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L2370-L2381 |
31 | ttacon/libphonenumber | phonenumberutil.go | TruncateTooLongNumber | func TruncateTooLongNumber(number *PhoneNumber) bool {
if IsValidNumber(number) {
return true
}
var numberCopy *PhoneNumber
proto.Merge(numberCopy, number)
nationalNumber := number.GetNationalNumber()
nationalNumber /= 10
numberCopy.NationalNumber = proto.Uint64(nationalNumber)
if IsPossibleNumberWithReason(numberCopy) == TOO_SHORT || nationalNumber == 0 {
return false
}
for !IsValidNumber(numberCopy) {
nationalNumber /= 10
numberCopy.NationalNumber = proto.Uint64(nationalNumber)
if IsPossibleNumberWithReason(numberCopy) == TOO_SHORT ||
nationalNumber == 0 {
return false
}
}
number.NationalNumber = proto.Uint64(nationalNumber)
return true
} | go | func TruncateTooLongNumber(number *PhoneNumber) bool {
if IsValidNumber(number) {
return true
}
var numberCopy *PhoneNumber
proto.Merge(numberCopy, number)
nationalNumber := number.GetNationalNumber()
nationalNumber /= 10
numberCopy.NationalNumber = proto.Uint64(nationalNumber)
if IsPossibleNumberWithReason(numberCopy) == TOO_SHORT || nationalNumber == 0 {
return false
}
for !IsValidNumber(numberCopy) {
nationalNumber /= 10
numberCopy.NationalNumber = proto.Uint64(nationalNumber)
if IsPossibleNumberWithReason(numberCopy) == TOO_SHORT ||
nationalNumber == 0 {
return false
}
}
number.NationalNumber = proto.Uint64(nationalNumber)
return true
} | [
"func",
"TruncateTooLongNumber",
"(",
"number",
"*",
"PhoneNumber",
")",
"bool",
"{",
"if",
"IsValidNumber",
"(",
"number",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"var",
"numberCopy",
"*",
"PhoneNumber",
"\n",
"proto",
".",
"Merge",
"(",
"numberCopy",
... | // Attempts to extract a valid number from a phone number that is too long
// to be valid, and resets the PhoneNumber object passed in to that valid
// version. If no valid number could be extracted, the PhoneNumber object
// passed in will not be modified. | [
"Attempts",
"to",
"extract",
"a",
"valid",
"number",
"from",
"a",
"phone",
"number",
"that",
"is",
"too",
"long",
"to",
"be",
"valid",
"and",
"resets",
"the",
"PhoneNumber",
"object",
"passed",
"in",
"to",
"that",
"valid",
"version",
".",
"If",
"no",
"va... | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L2457-L2480 |
32 | ttacon/libphonenumber | phonenumberutil.go | parsePrefixAsIdd | func parsePrefixAsIdd(iddPattern *regexp.Regexp, number *builder.Builder) bool {
numStr := number.String()
ind := iddPattern.FindStringIndex(numStr)
if len(ind) == 0 || ind[0] != 0 {
return false
}
matchEnd := ind[1] // ind is a two element slice
// Only strip this if the first digit after the match is not
// a 0, since country calling codes cannot begin with 0.
find := CAPTURING_DIGIT_PATTERN.FindAllString(numStr[matchEnd:], -1)
if len(find) > 0 {
if NormalizeDigitsOnly(find[0]) == "0" {
return false
}
}
numBytes := []byte(numStr)
number.ResetWith(numBytes[matchEnd:])
return true
} | go | func parsePrefixAsIdd(iddPattern *regexp.Regexp, number *builder.Builder) bool {
numStr := number.String()
ind := iddPattern.FindStringIndex(numStr)
if len(ind) == 0 || ind[0] != 0 {
return false
}
matchEnd := ind[1] // ind is a two element slice
// Only strip this if the first digit after the match is not
// a 0, since country calling codes cannot begin with 0.
find := CAPTURING_DIGIT_PATTERN.FindAllString(numStr[matchEnd:], -1)
if len(find) > 0 {
if NormalizeDigitsOnly(find[0]) == "0" {
return false
}
}
numBytes := []byte(numStr)
number.ResetWith(numBytes[matchEnd:])
return true
} | [
"func",
"parsePrefixAsIdd",
"(",
"iddPattern",
"*",
"regexp",
".",
"Regexp",
",",
"number",
"*",
"builder",
".",
"Builder",
")",
"bool",
"{",
"numStr",
":=",
"number",
".",
"String",
"(",
")",
"\n",
"ind",
":=",
"iddPattern",
".",
"FindStringIndex",
"(",
... | // Strips the IDD from the start of the number if present. Helper function
// used by maybeStripInternationalPrefixAndNormalize. | [
"Strips",
"the",
"IDD",
"from",
"the",
"start",
"of",
"the",
"number",
"if",
"present",
".",
"Helper",
"function",
"used",
"by",
"maybeStripInternationalPrefixAndNormalize",
"."
] | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L2625-L2644 |
33 | ttacon/libphonenumber | phonenumberutil.go | checkRegionForParsing | func checkRegionForParsing(numberToParse, defaultRegion string) bool {
if !isValidRegionCode(defaultRegion) {
// If the number is null or empty, we can't infer the region.
if len(numberToParse) == 0 ||
!PLUS_CHARS_PATTERN.MatchString(numberToParse) {
return false
}
}
return true
} | go | func checkRegionForParsing(numberToParse, defaultRegion string) bool {
if !isValidRegionCode(defaultRegion) {
// If the number is null or empty, we can't infer the region.
if len(numberToParse) == 0 ||
!PLUS_CHARS_PATTERN.MatchString(numberToParse) {
return false
}
}
return true
} | [
"func",
"checkRegionForParsing",
"(",
"numberToParse",
",",
"defaultRegion",
"string",
")",
"bool",
"{",
"if",
"!",
"isValidRegionCode",
"(",
"defaultRegion",
")",
"{",
"// If the number is null or empty, we can't infer the region.",
"if",
"len",
"(",
"numberToParse",
")"... | // Checks to see that the region code used is valid, or if it is not valid,
// that the number to parse starts with a + symbol so that we can attempt
// to infer the region from the number. Returns false if it cannot use the
// region provided and the region cannot be inferred. | [
"Checks",
"to",
"see",
"that",
"the",
"region",
"code",
"used",
"is",
"valid",
"or",
"if",
"it",
"is",
"not",
"valid",
"that",
"the",
"number",
"to",
"parse",
"starts",
"with",
"a",
"+",
"symbol",
"so",
"that",
"we",
"can",
"attempt",
"to",
"infer",
... | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L2786-L2795 |
34 | ttacon/libphonenumber | phonenumberutil.go | buildNationalNumberForParsing | func buildNationalNumberForParsing(
numberToParse string,
nationalNumber *builder.Builder) {
indexOfPhoneContext := strings.Index(numberToParse, RFC3966_PHONE_CONTEXT)
if indexOfPhoneContext > 0 {
phoneContextStart := indexOfPhoneContext + len(RFC3966_PHONE_CONTEXT)
// If the phone context contains a phone number prefix, we need
// to capture it, whereas domains will be ignored.
if numberToParse[phoneContextStart] == PLUS_SIGN {
// Additional parameters might follow the phone context. If so,
// we will remove them here because the parameters after phone
// context are not important for parsing the phone number.
phoneContextEnd := strings.Index(numberToParse[phoneContextStart:], ";")
if phoneContextEnd > 0 {
nationalNumber.WriteString(
numberToParse[phoneContextStart:phoneContextEnd])
} else {
nationalNumber.WriteString(numberToParse[phoneContextStart:])
}
}
// Now append everything between the "tel:" prefix and the
// phone-context. This should include the national number, an
// optional extension or isdn-subaddress component. Note we also
// handle the case when "tel:" is missing, as we have seen in some
// of the phone number inputs. In that case, we append everything
// from the beginning.
indexOfRfc3966Prefix := strings.Index(numberToParse, RFC3966_PREFIX)
indexOfNationalNumber := 0
if indexOfRfc3966Prefix >= 0 {
indexOfNationalNumber = indexOfRfc3966Prefix + len(RFC3966_PREFIX)
}
nationalNumber.WriteString(
numberToParse[indexOfNationalNumber:indexOfPhoneContext])
} else {
// Extract a possible number from the string passed in (this
// strips leading characters that could not be the start of a
// phone number.)
nationalNumber.WriteString(extractPossibleNumber(numberToParse))
}
// Delete the isdn-subaddress and everything after it if it is present.
// Note extension won't appear at the same time with isdn-subaddress
// according to paragraph 5.3 of the RFC3966 spec,
indexOfIsdn := strings.Index(nationalNumber.String(), RFC3966_ISDN_SUBADDRESS)
if indexOfIsdn > 0 {
natNumBytes := nationalNumber.Bytes()
nationalNumber.ResetWith(natNumBytes[:indexOfIsdn])
}
// If both phone context and isdn-subaddress are absent but other
// parameters are present, the parameters are left in nationalNumber.
// This is because we are concerned about deleting content from a
// potential number string when there is no strong evidence that the
// number is actually written in RFC3966.
} | go | func buildNationalNumberForParsing(
numberToParse string,
nationalNumber *builder.Builder) {
indexOfPhoneContext := strings.Index(numberToParse, RFC3966_PHONE_CONTEXT)
if indexOfPhoneContext > 0 {
phoneContextStart := indexOfPhoneContext + len(RFC3966_PHONE_CONTEXT)
// If the phone context contains a phone number prefix, we need
// to capture it, whereas domains will be ignored.
if numberToParse[phoneContextStart] == PLUS_SIGN {
// Additional parameters might follow the phone context. If so,
// we will remove them here because the parameters after phone
// context are not important for parsing the phone number.
phoneContextEnd := strings.Index(numberToParse[phoneContextStart:], ";")
if phoneContextEnd > 0 {
nationalNumber.WriteString(
numberToParse[phoneContextStart:phoneContextEnd])
} else {
nationalNumber.WriteString(numberToParse[phoneContextStart:])
}
}
// Now append everything between the "tel:" prefix and the
// phone-context. This should include the national number, an
// optional extension or isdn-subaddress component. Note we also
// handle the case when "tel:" is missing, as we have seen in some
// of the phone number inputs. In that case, we append everything
// from the beginning.
indexOfRfc3966Prefix := strings.Index(numberToParse, RFC3966_PREFIX)
indexOfNationalNumber := 0
if indexOfRfc3966Prefix >= 0 {
indexOfNationalNumber = indexOfRfc3966Prefix + len(RFC3966_PREFIX)
}
nationalNumber.WriteString(
numberToParse[indexOfNationalNumber:indexOfPhoneContext])
} else {
// Extract a possible number from the string passed in (this
// strips leading characters that could not be the start of a
// phone number.)
nationalNumber.WriteString(extractPossibleNumber(numberToParse))
}
// Delete the isdn-subaddress and everything after it if it is present.
// Note extension won't appear at the same time with isdn-subaddress
// according to paragraph 5.3 of the RFC3966 spec,
indexOfIsdn := strings.Index(nationalNumber.String(), RFC3966_ISDN_SUBADDRESS)
if indexOfIsdn > 0 {
natNumBytes := nationalNumber.Bytes()
nationalNumber.ResetWith(natNumBytes[:indexOfIsdn])
}
// If both phone context and isdn-subaddress are absent but other
// parameters are present, the parameters are left in nationalNumber.
// This is because we are concerned about deleting content from a
// potential number string when there is no strong evidence that the
// number is actually written in RFC3966.
} | [
"func",
"buildNationalNumberForParsing",
"(",
"numberToParse",
"string",
",",
"nationalNumber",
"*",
"builder",
".",
"Builder",
")",
"{",
"indexOfPhoneContext",
":=",
"strings",
".",
"Index",
"(",
"numberToParse",
",",
"RFC3966_PHONE_CONTEXT",
")",
"\n",
"if",
"inde... | // Converts numberToParse to a form that we can parse and write it to
// nationalNumber if it is written in RFC3966; otherwise extract a possible
// number out of it and write to nationalNumber. | [
"Converts",
"numberToParse",
"to",
"a",
"form",
"that",
"we",
"can",
"parse",
"and",
"write",
"it",
"to",
"nationalNumber",
"if",
"it",
"is",
"written",
"in",
"RFC3966",
";",
"otherwise",
"extract",
"a",
"possible",
"number",
"out",
"of",
"it",
"and",
"wri... | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L3009-L3063 |
35 | ttacon/libphonenumber | phonenumberutil.go | isNumberMatchWithNumbers | func isNumberMatchWithNumbers(firstNumberIn, secondNumberIn *PhoneNumber) MatchType {
// Make copies of the phone number so that the numbers passed in are not edited.
var firstNumber, secondNumber *PhoneNumber
firstNumber = &PhoneNumber{}
secondNumber = &PhoneNumber{}
proto.Merge(firstNumber, firstNumberIn)
proto.Merge(secondNumber, secondNumberIn)
// First clear raw_input, country_code_source and
// preferred_domestic_carrier_code fields and any empty-string
// extensions so that we can use the proto-buffer equality method.
firstNumber.RawInput = nil
firstNumber.CountryCodeSource = nil
firstNumber.PreferredDomesticCarrierCode = nil
secondNumber.RawInput = nil
secondNumber.CountryCodeSource = nil
secondNumber.PreferredDomesticCarrierCode = nil
firstNumExt := firstNumber.GetExtension()
secondNumExt := secondNumber.GetExtension()
// NOTE(ttacon): don't think we need this in go land...
if len(firstNumExt) == 0 {
firstNumber.Extension = nil
}
if len(secondNumExt) == 0 {
secondNumber.Extension = nil
}
// Early exit if both had extensions and these are different.
if len(firstNumExt) > 0 && len(secondNumExt) > 0 &&
firstNumExt != secondNumExt {
return NO_MATCH
}
var (
firstNumberCountryCode = firstNumber.GetCountryCode()
secondNumberCountryCode = secondNumber.GetCountryCode()
)
// Both had country_code specified.
if firstNumberCountryCode != 0 && secondNumberCountryCode != 0 {
// TODO(ttacon): remove when make gen-equals
if reflect.DeepEqual(firstNumber, secondNumber) {
return EXACT_MATCH
} else if firstNumberCountryCode == secondNumberCountryCode &&
isNationalNumberSuffixOfTheOther(firstNumber, secondNumber) {
// A SHORT_NSN_MATCH occurs if there is a difference because of
// the presence or absence of an 'Italian leading zero', the
// presence or absence of an extension, or one NSN being a
// shorter variant of the other.
return SHORT_NSN_MATCH
}
// This is not a match.
return NO_MATCH
}
// Checks cases where one or both country_code fields were not
// specified. To make equality checks easier, we first set the
// country_code fields to be equal.
firstNumber.CountryCode = proto.Int(int(secondNumberCountryCode))
// If all else was the same, then this is an NSN_MATCH.
// TODO(ttacon): remove when make gen-equals
if reflect.DeepEqual(firstNumber, secondNumber) {
return NSN_MATCH
}
if isNationalNumberSuffixOfTheOther(firstNumber, secondNumber) {
return SHORT_NSN_MATCH
}
return NO_MATCH
} | go | func isNumberMatchWithNumbers(firstNumberIn, secondNumberIn *PhoneNumber) MatchType {
// Make copies of the phone number so that the numbers passed in are not edited.
var firstNumber, secondNumber *PhoneNumber
firstNumber = &PhoneNumber{}
secondNumber = &PhoneNumber{}
proto.Merge(firstNumber, firstNumberIn)
proto.Merge(secondNumber, secondNumberIn)
// First clear raw_input, country_code_source and
// preferred_domestic_carrier_code fields and any empty-string
// extensions so that we can use the proto-buffer equality method.
firstNumber.RawInput = nil
firstNumber.CountryCodeSource = nil
firstNumber.PreferredDomesticCarrierCode = nil
secondNumber.RawInput = nil
secondNumber.CountryCodeSource = nil
secondNumber.PreferredDomesticCarrierCode = nil
firstNumExt := firstNumber.GetExtension()
secondNumExt := secondNumber.GetExtension()
// NOTE(ttacon): don't think we need this in go land...
if len(firstNumExt) == 0 {
firstNumber.Extension = nil
}
if len(secondNumExt) == 0 {
secondNumber.Extension = nil
}
// Early exit if both had extensions and these are different.
if len(firstNumExt) > 0 && len(secondNumExt) > 0 &&
firstNumExt != secondNumExt {
return NO_MATCH
}
var (
firstNumberCountryCode = firstNumber.GetCountryCode()
secondNumberCountryCode = secondNumber.GetCountryCode()
)
// Both had country_code specified.
if firstNumberCountryCode != 0 && secondNumberCountryCode != 0 {
// TODO(ttacon): remove when make gen-equals
if reflect.DeepEqual(firstNumber, secondNumber) {
return EXACT_MATCH
} else if firstNumberCountryCode == secondNumberCountryCode &&
isNationalNumberSuffixOfTheOther(firstNumber, secondNumber) {
// A SHORT_NSN_MATCH occurs if there is a difference because of
// the presence or absence of an 'Italian leading zero', the
// presence or absence of an extension, or one NSN being a
// shorter variant of the other.
return SHORT_NSN_MATCH
}
// This is not a match.
return NO_MATCH
}
// Checks cases where one or both country_code fields were not
// specified. To make equality checks easier, we first set the
// country_code fields to be equal.
firstNumber.CountryCode = proto.Int(int(secondNumberCountryCode))
// If all else was the same, then this is an NSN_MATCH.
// TODO(ttacon): remove when make gen-equals
if reflect.DeepEqual(firstNumber, secondNumber) {
return NSN_MATCH
}
if isNationalNumberSuffixOfTheOther(firstNumber, secondNumber) {
return SHORT_NSN_MATCH
}
return NO_MATCH
} | [
"func",
"isNumberMatchWithNumbers",
"(",
"firstNumberIn",
",",
"secondNumberIn",
"*",
"PhoneNumber",
")",
"MatchType",
"{",
"// Make copies of the phone number so that the numbers passed in are not edited.",
"var",
"firstNumber",
",",
"secondNumber",
"*",
"PhoneNumber",
"\n",
"... | // Takes two phone numbers and compares them for equality.
//
// Returns EXACT_MATCH if the country_code, NSN, presence of a leading zero
// for Italian numbers and any extension present are the same.
// Returns NSN_MATCH if either or both has no region specified, and the NSNs
// and extensions are the same.
// Returns SHORT_NSN_MATCH if either or both has no region specified, or the
// region specified is the same, and one NSN could be a shorter version of
// the other number. This includes the case where one has an extension
// specified, and the other does not.
// Returns NO_MATCH otherwise.
// For example, the numbers +1 345 657 1234 and 657 1234 are a SHORT_NSN_MATCH.
// The numbers +1 345 657 1234 and 345 657 are a NO_MATCH. | [
"Takes",
"two",
"phone",
"numbers",
"and",
"compares",
"them",
"for",
"equality",
".",
"Returns",
"EXACT_MATCH",
"if",
"the",
"country_code",
"NSN",
"presence",
"of",
"a",
"leading",
"zero",
"for",
"Italian",
"numbers",
"and",
"any",
"extension",
"present",
"a... | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L3078-L3143 |
36 | ttacon/libphonenumber | phonenumberutil.go | isNationalNumberSuffixOfTheOther | func isNationalNumberSuffixOfTheOther(firstNumber, secondNumber *PhoneNumber) bool {
var (
firstNumberNationalNumber = strconv.FormatUint(
firstNumber.GetNationalNumber(), 10)
secondNumberNationalNumber = strconv.FormatUint(
secondNumber.GetNationalNumber(), 10)
)
// Note that endsWith returns true if the numbers are equal.
return strings.HasSuffix(firstNumberNationalNumber, secondNumberNationalNumber) ||
strings.HasSuffix(secondNumberNationalNumber, firstNumberNationalNumber)
} | go | func isNationalNumberSuffixOfTheOther(firstNumber, secondNumber *PhoneNumber) bool {
var (
firstNumberNationalNumber = strconv.FormatUint(
firstNumber.GetNationalNumber(), 10)
secondNumberNationalNumber = strconv.FormatUint(
secondNumber.GetNationalNumber(), 10)
)
// Note that endsWith returns true if the numbers are equal.
return strings.HasSuffix(firstNumberNationalNumber, secondNumberNationalNumber) ||
strings.HasSuffix(secondNumberNationalNumber, firstNumberNationalNumber)
} | [
"func",
"isNationalNumberSuffixOfTheOther",
"(",
"firstNumber",
",",
"secondNumber",
"*",
"PhoneNumber",
")",
"bool",
"{",
"var",
"(",
"firstNumberNationalNumber",
"=",
"strconv",
".",
"FormatUint",
"(",
"firstNumber",
".",
"GetNationalNumber",
"(",
")",
",",
"10",
... | // Returns true when one national number is the suffix of the other or both
// are the same. | [
"Returns",
"true",
"when",
"one",
"national",
"number",
"is",
"the",
"suffix",
"of",
"the",
"other",
"or",
"both",
"are",
"the",
"same",
"."
] | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L3147-L3157 |
37 | ttacon/libphonenumber | phonenumberutil.go | IsMobileNumberPortableRegion | func IsMobileNumberPortableRegion(regionCode string) bool {
metadata := getMetadataForRegion(regionCode)
if metadata == nil {
return false
}
return metadata.GetMobileNumberPortableRegion()
} | go | func IsMobileNumberPortableRegion(regionCode string) bool {
metadata := getMetadataForRegion(regionCode)
if metadata == nil {
return false
}
return metadata.GetMobileNumberPortableRegion()
} | [
"func",
"IsMobileNumberPortableRegion",
"(",
"regionCode",
"string",
")",
"bool",
"{",
"metadata",
":=",
"getMetadataForRegion",
"(",
"regionCode",
")",
"\n",
"if",
"metadata",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"metadata",
".",
"G... | // Returns true if the supplied region supports mobile number portability.
// Returns false for invalid, unknown or regions that don't support mobile
// number portability. | [
"Returns",
"true",
"if",
"the",
"supplied",
"region",
"supports",
"mobile",
"number",
"portability",
".",
"Returns",
"false",
"for",
"invalid",
"unknown",
"or",
"regions",
"that",
"don",
"t",
"support",
"mobile",
"number",
"portability",
"."
] | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/phonenumberutil.go#L3254-L3260 |
38 | ttacon/libphonenumber | countryCodeToTimeZones.go | GetTimeZonesForRegion | func GetTimeZonesForRegion(number string) ([]string, error) {
for i := MAX_REGION_CODE_LENGTH; i > 0; i-- {
index, err := strconv.Atoi(number[0:i])
if err != nil {
return nil, err
}
if CountryCodeToTimeZones[index] != nil {
return CountryCodeToTimeZones[index], nil
}
}
return []string{UNKNOWN_TIMEZONE}, nil
} | go | func GetTimeZonesForRegion(number string) ([]string, error) {
for i := MAX_REGION_CODE_LENGTH; i > 0; i-- {
index, err := strconv.Atoi(number[0:i])
if err != nil {
return nil, err
}
if CountryCodeToTimeZones[index] != nil {
return CountryCodeToTimeZones[index], nil
}
}
return []string{UNKNOWN_TIMEZONE}, nil
} | [
"func",
"GetTimeZonesForRegion",
"(",
"number",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"for",
"i",
":=",
"MAX_REGION_CODE_LENGTH",
";",
"i",
">",
"0",
";",
"i",
"--",
"{",
"index",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(... | // Returns a slice of Timezones corresponding to the number passed
// or error when it is impossible to convert the string to int
// The algorythm tries to match the timezones starting from the maximum
// number of phone number digits and decreasing until it finds one or reaches 0 | [
"Returns",
"a",
"slice",
"of",
"Timezones",
"corresponding",
"to",
"the",
"number",
"passed",
"or",
"error",
"when",
"it",
"is",
"impossible",
"to",
"convert",
"the",
"string",
"to",
"int",
"The",
"algorythm",
"tries",
"to",
"match",
"the",
"timezones",
"sta... | 23ddf903e8f8800d2857645eb155ffbe15cd02ee | https://github.com/ttacon/libphonenumber/blob/23ddf903e8f8800d2857645eb155ffbe15cd02ee/countryCodeToTimeZones.go#L2253-L2264 |
39 | hajimehoshi/go-mp3 | decode.go | Read | func (d *Decoder) Read(buf []byte) (int, error) {
for len(d.buf) == 0 {
if err := d.readFrame(); err != nil {
return 0, err
}
}
n := copy(buf, d.buf)
d.buf = d.buf[n:]
d.pos += int64(n)
return n, nil
} | go | func (d *Decoder) Read(buf []byte) (int, error) {
for len(d.buf) == 0 {
if err := d.readFrame(); err != nil {
return 0, err
}
}
n := copy(buf, d.buf)
d.buf = d.buf[n:]
d.pos += int64(n)
return n, nil
} | [
"func",
"(",
"d",
"*",
"Decoder",
")",
"Read",
"(",
"buf",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"for",
"len",
"(",
"d",
".",
"buf",
")",
"==",
"0",
"{",
"if",
"err",
":=",
"d",
".",
"readFrame",
"(",
")",
";",
"err",
... | // Read is io.Reader's Read. | [
"Read",
"is",
"io",
".",
"Reader",
"s",
"Read",
"."
] | 14af46a99b16fe1e285e22e032579d8b075c71f4 | https://github.com/hajimehoshi/go-mp3/blob/14af46a99b16fe1e285e22e032579d8b075c71f4/decode.go#L57-L67 |
40 | hajimehoshi/go-mp3 | decode.go | Seek | func (d *Decoder) Seek(offset int64, whence int) (int64, error) {
npos := int64(0)
switch whence {
case io.SeekStart:
npos = offset
case io.SeekCurrent:
npos = d.pos + offset
case io.SeekEnd:
npos = d.Length() + offset
default:
panic(fmt.Sprintf("mp3: invalid whence: %v", whence))
}
d.pos = npos
d.buf = nil
d.frame = nil
f := d.pos / consts.BytesPerFrame
// If the frame is not first, read the previous ahead of reading that
// because the previous frame can affect the targeted frame.
if f > 0 {
f--
if _, err := d.source.Seek(d.frameStarts[f], 0); err != nil {
return 0, err
}
if err := d.readFrame(); err != nil {
return 0, err
}
if err := d.readFrame(); err != nil {
return 0, err
}
d.buf = d.buf[consts.BytesPerFrame+(d.pos%consts.BytesPerFrame):]
} else {
if _, err := d.source.Seek(d.frameStarts[f], 0); err != nil {
return 0, err
}
if err := d.readFrame(); err != nil {
return 0, err
}
d.buf = d.buf[d.pos:]
}
return npos, nil
} | go | func (d *Decoder) Seek(offset int64, whence int) (int64, error) {
npos := int64(0)
switch whence {
case io.SeekStart:
npos = offset
case io.SeekCurrent:
npos = d.pos + offset
case io.SeekEnd:
npos = d.Length() + offset
default:
panic(fmt.Sprintf("mp3: invalid whence: %v", whence))
}
d.pos = npos
d.buf = nil
d.frame = nil
f := d.pos / consts.BytesPerFrame
// If the frame is not first, read the previous ahead of reading that
// because the previous frame can affect the targeted frame.
if f > 0 {
f--
if _, err := d.source.Seek(d.frameStarts[f], 0); err != nil {
return 0, err
}
if err := d.readFrame(); err != nil {
return 0, err
}
if err := d.readFrame(); err != nil {
return 0, err
}
d.buf = d.buf[consts.BytesPerFrame+(d.pos%consts.BytesPerFrame):]
} else {
if _, err := d.source.Seek(d.frameStarts[f], 0); err != nil {
return 0, err
}
if err := d.readFrame(); err != nil {
return 0, err
}
d.buf = d.buf[d.pos:]
}
return npos, nil
} | [
"func",
"(",
"d",
"*",
"Decoder",
")",
"Seek",
"(",
"offset",
"int64",
",",
"whence",
"int",
")",
"(",
"int64",
",",
"error",
")",
"{",
"npos",
":=",
"int64",
"(",
"0",
")",
"\n",
"switch",
"whence",
"{",
"case",
"io",
".",
"SeekStart",
":",
"npo... | // Seek is io.Seeker's Seek.
//
// Seek panics when the underlying source is not io.Seeker. | [
"Seek",
"is",
"io",
".",
"Seeker",
"s",
"Seek",
".",
"Seek",
"panics",
"when",
"the",
"underlying",
"source",
"is",
"not",
"io",
".",
"Seeker",
"."
] | 14af46a99b16fe1e285e22e032579d8b075c71f4 | https://github.com/hajimehoshi/go-mp3/blob/14af46a99b16fe1e285e22e032579d8b075c71f4/decode.go#L72-L112 |
41 | hajimehoshi/go-mp3 | internal/frameheader/frameheader.go | IsValid | func (f FrameHeader) IsValid() bool {
const sync = 0xffe00000
if (f & sync) != sync {
return false
}
if f.ID() == consts.VersionReserved {
return false
}
if f.BitrateIndex() == 15 {
return false
}
if f.SamplingFrequency() == consts.SamplingFrequencyReserved {
return false
}
if f.Layer() == consts.LayerReserved {
return false
}
if f.Emphasis() == 2 {
return false
}
return true
} | go | func (f FrameHeader) IsValid() bool {
const sync = 0xffe00000
if (f & sync) != sync {
return false
}
if f.ID() == consts.VersionReserved {
return false
}
if f.BitrateIndex() == 15 {
return false
}
if f.SamplingFrequency() == consts.SamplingFrequencyReserved {
return false
}
if f.Layer() == consts.LayerReserved {
return false
}
if f.Emphasis() == 2 {
return false
}
return true
} | [
"func",
"(",
"f",
"FrameHeader",
")",
"IsValid",
"(",
")",
"bool",
"{",
"const",
"sync",
"=",
"0xffe00000",
"\n",
"if",
"(",
"f",
"&",
"sync",
")",
"!=",
"sync",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"f",
".",
"ID",
"(",
")",
"==",
"co... | // IsValid returns a boolean value indicating whether the header is valid or not. | [
"IsValid",
"returns",
"a",
"boolean",
"value",
"indicating",
"whether",
"the",
"header",
"is",
"valid",
"or",
"not",
"."
] | 14af46a99b16fe1e285e22e032579d8b075c71f4 | https://github.com/hajimehoshi/go-mp3/blob/14af46a99b16fe1e285e22e032579d8b075c71f4/internal/frameheader/frameheader.go#L105-L126 |
42 | seiflotfy/cuckoofilter | cuckoofilter.go | NewFilter | func NewFilter(capacity uint) *Filter {
capacity = getNextPow2(uint64(capacity)) / bucketSize
if capacity == 0 {
capacity = 1
}
buckets := make([]bucket, capacity)
for i := range buckets {
buckets[i] = [bucketSize]byte{}
}
return &Filter{buckets, 0}
} | go | func NewFilter(capacity uint) *Filter {
capacity = getNextPow2(uint64(capacity)) / bucketSize
if capacity == 0 {
capacity = 1
}
buckets := make([]bucket, capacity)
for i := range buckets {
buckets[i] = [bucketSize]byte{}
}
return &Filter{buckets, 0}
} | [
"func",
"NewFilter",
"(",
"capacity",
"uint",
")",
"*",
"Filter",
"{",
"capacity",
"=",
"getNextPow2",
"(",
"uint64",
"(",
"capacity",
")",
")",
"/",
"bucketSize",
"\n",
"if",
"capacity",
"==",
"0",
"{",
"capacity",
"=",
"1",
"\n",
"}",
"\n",
"buckets"... | // NewFilter returns a new cuckoofilter with a given capacity.
// A capacity of 1000000 is a normal default, which allocates
// about ~1MB on 64-bit machines. | [
"NewFilter",
"returns",
"a",
"new",
"cuckoofilter",
"with",
"a",
"given",
"capacity",
".",
"A",
"capacity",
"of",
"1000000",
"is",
"a",
"normal",
"default",
"which",
"allocates",
"about",
"~1MB",
"on",
"64",
"-",
"bit",
"machines",
"."
] | 764cb5258d9bcd276f2f809e74cfa206d8e8e054 | https://github.com/seiflotfy/cuckoofilter/blob/764cb5258d9bcd276f2f809e74cfa206d8e8e054/cuckoofilter.go#L19-L29 |
43 | seiflotfy/cuckoofilter | cuckoofilter.go | Lookup | func (cf *Filter) Lookup(data []byte) bool {
i1, i2, fp := getIndicesAndFingerprint(data, uint(len(cf.buckets)))
b1, b2 := cf.buckets[i1], cf.buckets[i2]
return b1.getFingerprintIndex(fp) > -1 || b2.getFingerprintIndex(fp) > -1
} | go | func (cf *Filter) Lookup(data []byte) bool {
i1, i2, fp := getIndicesAndFingerprint(data, uint(len(cf.buckets)))
b1, b2 := cf.buckets[i1], cf.buckets[i2]
return b1.getFingerprintIndex(fp) > -1 || b2.getFingerprintIndex(fp) > -1
} | [
"func",
"(",
"cf",
"*",
"Filter",
")",
"Lookup",
"(",
"data",
"[",
"]",
"byte",
")",
"bool",
"{",
"i1",
",",
"i2",
",",
"fp",
":=",
"getIndicesAndFingerprint",
"(",
"data",
",",
"uint",
"(",
"len",
"(",
"cf",
".",
"buckets",
")",
")",
")",
"\n",
... | // Lookup returns true if data is in the counter | [
"Lookup",
"returns",
"true",
"if",
"data",
"is",
"in",
"the",
"counter"
] | 764cb5258d9bcd276f2f809e74cfa206d8e8e054 | https://github.com/seiflotfy/cuckoofilter/blob/764cb5258d9bcd276f2f809e74cfa206d8e8e054/cuckoofilter.go#L32-L36 |
44 | seiflotfy/cuckoofilter | cuckoofilter.go | Insert | func (cf *Filter) Insert(data []byte) bool {
i1, i2, fp := getIndicesAndFingerprint(data, uint(len(cf.buckets)))
if cf.insert(fp, i1) || cf.insert(fp, i2) {
return true
}
return cf.reinsert(fp, randi(i1, i2))
} | go | func (cf *Filter) Insert(data []byte) bool {
i1, i2, fp := getIndicesAndFingerprint(data, uint(len(cf.buckets)))
if cf.insert(fp, i1) || cf.insert(fp, i2) {
return true
}
return cf.reinsert(fp, randi(i1, i2))
} | [
"func",
"(",
"cf",
"*",
"Filter",
")",
"Insert",
"(",
"data",
"[",
"]",
"byte",
")",
"bool",
"{",
"i1",
",",
"i2",
",",
"fp",
":=",
"getIndicesAndFingerprint",
"(",
"data",
",",
"uint",
"(",
"len",
"(",
"cf",
".",
"buckets",
")",
")",
")",
"\n",
... | // Insert inserts data into the counter and returns true upon success | [
"Insert",
"inserts",
"data",
"into",
"the",
"counter",
"and",
"returns",
"true",
"upon",
"success"
] | 764cb5258d9bcd276f2f809e74cfa206d8e8e054 | https://github.com/seiflotfy/cuckoofilter/blob/764cb5258d9bcd276f2f809e74cfa206d8e8e054/cuckoofilter.go#L53-L59 |
45 | seiflotfy/cuckoofilter | cuckoofilter.go | InsertUnique | func (cf *Filter) InsertUnique(data []byte) bool {
if cf.Lookup(data) {
return false
}
return cf.Insert(data)
} | go | func (cf *Filter) InsertUnique(data []byte) bool {
if cf.Lookup(data) {
return false
}
return cf.Insert(data)
} | [
"func",
"(",
"cf",
"*",
"Filter",
")",
"InsertUnique",
"(",
"data",
"[",
"]",
"byte",
")",
"bool",
"{",
"if",
"cf",
".",
"Lookup",
"(",
"data",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"cf",
".",
"Insert",
"(",
"data",
")",
"\n",
... | // InsertUnique inserts data into the counter if not exists and returns true upon success | [
"InsertUnique",
"inserts",
"data",
"into",
"the",
"counter",
"if",
"not",
"exists",
"and",
"returns",
"true",
"upon",
"success"
] | 764cb5258d9bcd276f2f809e74cfa206d8e8e054 | https://github.com/seiflotfy/cuckoofilter/blob/764cb5258d9bcd276f2f809e74cfa206d8e8e054/cuckoofilter.go#L62-L67 |
46 | seiflotfy/cuckoofilter | cuckoofilter.go | Delete | func (cf *Filter) Delete(data []byte) bool {
i1, i2, fp := getIndicesAndFingerprint(data, uint(len(cf.buckets)))
return cf.delete(fp, i1) || cf.delete(fp, i2)
} | go | func (cf *Filter) Delete(data []byte) bool {
i1, i2, fp := getIndicesAndFingerprint(data, uint(len(cf.buckets)))
return cf.delete(fp, i1) || cf.delete(fp, i2)
} | [
"func",
"(",
"cf",
"*",
"Filter",
")",
"Delete",
"(",
"data",
"[",
"]",
"byte",
")",
"bool",
"{",
"i1",
",",
"i2",
",",
"fp",
":=",
"getIndicesAndFingerprint",
"(",
"data",
",",
"uint",
"(",
"len",
"(",
"cf",
".",
"buckets",
")",
")",
")",
"\n",
... | // Delete data from counter if exists and return if deleted or not | [
"Delete",
"data",
"from",
"counter",
"if",
"exists",
"and",
"return",
"if",
"deleted",
"or",
"not"
] | 764cb5258d9bcd276f2f809e74cfa206d8e8e054 | https://github.com/seiflotfy/cuckoofilter/blob/764cb5258d9bcd276f2f809e74cfa206d8e8e054/cuckoofilter.go#L94-L97 |
47 | seiflotfy/cuckoofilter | cuckoofilter.go | Encode | func (cf *Filter) Encode() []byte {
bytes := make([]byte, len(cf.buckets)*bucketSize)
for i, b := range cf.buckets {
for j, f := range b {
index := (i * len(b)) + j
bytes[index] = f
}
}
return bytes
} | go | func (cf *Filter) Encode() []byte {
bytes := make([]byte, len(cf.buckets)*bucketSize)
for i, b := range cf.buckets {
for j, f := range b {
index := (i * len(b)) + j
bytes[index] = f
}
}
return bytes
} | [
"func",
"(",
"cf",
"*",
"Filter",
")",
"Encode",
"(",
")",
"[",
"]",
"byte",
"{",
"bytes",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"len",
"(",
"cf",
".",
"buckets",
")",
"*",
"bucketSize",
")",
"\n",
"for",
"i",
",",
"b",
":=",
"range",
"cf... | // Encode returns a byte slice representing a Cuckoofilter | [
"Encode",
"returns",
"a",
"byte",
"slice",
"representing",
"a",
"Cuckoofilter"
] | 764cb5258d9bcd276f2f809e74cfa206d8e8e054 | https://github.com/seiflotfy/cuckoofilter/blob/764cb5258d9bcd276f2f809e74cfa206d8e8e054/cuckoofilter.go#L113-L122 |
48 | seiflotfy/cuckoofilter | cuckoofilter.go | Decode | func Decode(bytes []byte) (*Filter, error) {
var count uint
if len(bytes)%bucketSize != 0 {
return nil, fmt.Errorf("expected bytes to be multiple of %d, got %d", bucketSize, len(bytes))
}
buckets := make([]bucket, len(bytes)/4)
for i, b := range buckets {
for j := range b {
index := (i * len(b)) + j
if bytes[index] != 0 {
buckets[i][j] = bytes[index]
count++
}
}
}
return &Filter{
buckets: buckets,
count: count,
}, nil
} | go | func Decode(bytes []byte) (*Filter, error) {
var count uint
if len(bytes)%bucketSize != 0 {
return nil, fmt.Errorf("expected bytes to be multiple of %d, got %d", bucketSize, len(bytes))
}
buckets := make([]bucket, len(bytes)/4)
for i, b := range buckets {
for j := range b {
index := (i * len(b)) + j
if bytes[index] != 0 {
buckets[i][j] = bytes[index]
count++
}
}
}
return &Filter{
buckets: buckets,
count: count,
}, nil
} | [
"func",
"Decode",
"(",
"bytes",
"[",
"]",
"byte",
")",
"(",
"*",
"Filter",
",",
"error",
")",
"{",
"var",
"count",
"uint",
"\n",
"if",
"len",
"(",
"bytes",
")",
"%",
"bucketSize",
"!=",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
... | // Decode returns a Cuckoofilter from a byte slice | [
"Decode",
"returns",
"a",
"Cuckoofilter",
"from",
"a",
"byte",
"slice"
] | 764cb5258d9bcd276f2f809e74cfa206d8e8e054 | https://github.com/seiflotfy/cuckoofilter/blob/764cb5258d9bcd276f2f809e74cfa206d8e8e054/cuckoofilter.go#L125-L144 |
49 | seiflotfy/cuckoofilter | util.go | getIndicesAndFingerprint | func getIndicesAndFingerprint(data []byte, numBuckets uint) (uint, uint, byte) {
hash := metro.Hash64(data, 1337)
f := getFingerprint(data)
i1 := uint(hash) % numBuckets
i2 := getAltIndex(f, i1, numBuckets)
return i1, i2, f
} | go | func getIndicesAndFingerprint(data []byte, numBuckets uint) (uint, uint, byte) {
hash := metro.Hash64(data, 1337)
f := getFingerprint(data)
i1 := uint(hash) % numBuckets
i2 := getAltIndex(f, i1, numBuckets)
return i1, i2, f
} | [
"func",
"getIndicesAndFingerprint",
"(",
"data",
"[",
"]",
"byte",
",",
"numBuckets",
"uint",
")",
"(",
"uint",
",",
"uint",
",",
"byte",
")",
"{",
"hash",
":=",
"metro",
".",
"Hash64",
"(",
"data",
",",
"1337",
")",
"\n",
"f",
":=",
"getFingerprint",
... | // getIndicesAndFingerprint returns the 2 bucket indices and fingerprint to be used | [
"getIndicesAndFingerprint",
"returns",
"the",
"2",
"bucket",
"indices",
"and",
"fingerprint",
"to",
"be",
"used"
] | 764cb5258d9bcd276f2f809e74cfa206d8e8e054 | https://github.com/seiflotfy/cuckoofilter/blob/764cb5258d9bcd276f2f809e74cfa206d8e8e054/util.go#L18-L24 |
50 | markbates/grift | grift/grift.go | Namespace | func Namespace(name string, s func()) error {
defer func() {
namespace = ""
}()
namespace = applyNamespace(name)
s()
return nil
} | go | func Namespace(name string, s func()) error {
defer func() {
namespace = ""
}()
namespace = applyNamespace(name)
s()
return nil
} | [
"func",
"Namespace",
"(",
"name",
"string",
",",
"s",
"func",
"(",
")",
")",
"error",
"{",
"defer",
"func",
"(",
")",
"{",
"namespace",
"=",
"\"",
"\"",
"\n",
"}",
"(",
")",
"\n\n",
"namespace",
"=",
"applyNamespace",
"(",
"name",
")",
"\n",
"s",
... | // Namespace will place all tasks within the given prefix. | [
"Namespace",
"will",
"place",
"all",
"tasks",
"within",
"the",
"given",
"prefix",
"."
] | ce869fe62d84875913170d186f91a34667e4c732 | https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/grift.go#L24-L32 |
51 | markbates/grift | grift/grift.go | Add | func Add(name string, grift Grift) error {
lock.Lock()
defer lock.Unlock()
name = applyNamespace(name)
if griftList[name] != nil {
fn := griftList[name]
griftList[name] = func(c *Context) error {
err := fn(c)
if err != nil {
return err
}
return grift(c)
}
} else {
griftList[name] = grift
}
return nil
} | go | func Add(name string, grift Grift) error {
lock.Lock()
defer lock.Unlock()
name = applyNamespace(name)
if griftList[name] != nil {
fn := griftList[name]
griftList[name] = func(c *Context) error {
err := fn(c)
if err != nil {
return err
}
return grift(c)
}
} else {
griftList[name] = grift
}
return nil
} | [
"func",
"Add",
"(",
"name",
"string",
",",
"grift",
"Grift",
")",
"error",
"{",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"name",
"=",
"applyNamespace",
"(",
"name",
")",
"\n\n",
"if",
"griftList",
"[",
... | // Add a grift. If there is already a grift
// with the given name the two grifts will
// be bundled together. | [
"Add",
"a",
"grift",
".",
"If",
"there",
"is",
"already",
"a",
"grift",
"with",
"the",
"given",
"name",
"the",
"two",
"grifts",
"will",
"be",
"bundled",
"together",
"."
] | ce869fe62d84875913170d186f91a34667e4c732 | https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/grift.go#L51-L70 |
52 | markbates/grift | grift/grift.go | Set | func Set(name string, grift Grift) error {
lock.Lock()
defer lock.Unlock()
name = applyNamespace(name)
griftList[name] = grift
return nil
} | go | func Set(name string, grift Grift) error {
lock.Lock()
defer lock.Unlock()
name = applyNamespace(name)
griftList[name] = grift
return nil
} | [
"func",
"Set",
"(",
"name",
"string",
",",
"grift",
"Grift",
")",
"error",
"{",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"name",
"=",
"applyNamespace",
"(",
"name",
")",
"\n",
"griftList",
"[",
"name",
"]... | // Set a grift. This is similar to `Add` but it will
// overwrite an existing grift with the same name. | [
"Set",
"a",
"grift",
".",
"This",
"is",
"similar",
"to",
"Add",
"but",
"it",
"will",
"overwrite",
"an",
"existing",
"grift",
"with",
"the",
"same",
"name",
"."
] | ce869fe62d84875913170d186f91a34667e4c732 | https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/grift.go#L74-L80 |
53 | markbates/grift | grift/grift.go | Rename | func Rename(oldName string, newName string) error {
lock.Lock()
defer lock.Unlock()
oldName = applyNamespace(oldName)
newName = applyNamespace(newName)
if griftList[oldName] == nil {
return fmt.Errorf("No task named %s defined!", oldName)
}
griftList[newName] = griftList[oldName]
delete(griftList, oldName)
return nil
} | go | func Rename(oldName string, newName string) error {
lock.Lock()
defer lock.Unlock()
oldName = applyNamespace(oldName)
newName = applyNamespace(newName)
if griftList[oldName] == nil {
return fmt.Errorf("No task named %s defined!", oldName)
}
griftList[newName] = griftList[oldName]
delete(griftList, oldName)
return nil
} | [
"func",
"Rename",
"(",
"oldName",
"string",
",",
"newName",
"string",
")",
"error",
"{",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"oldName",
"=",
"applyNamespace",
"(",
"oldName",
")",
"\n",
"newName",
"=",... | // Rename a grift. Useful if you want to re-define
// an existing grift, but don't want to write over
// the original. | [
"Rename",
"a",
"grift",
".",
"Useful",
"if",
"you",
"want",
"to",
"re",
"-",
"define",
"an",
"existing",
"grift",
"but",
"don",
"t",
"want",
"to",
"write",
"over",
"the",
"original",
"."
] | ce869fe62d84875913170d186f91a34667e4c732 | https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/grift.go#L85-L98 |
54 | markbates/grift | grift/grift.go | Remove | func Remove(name string) error {
lock.Lock()
defer lock.Unlock()
name = applyNamespace(name)
delete(griftList, name)
delete(descriptions, name)
return nil
} | go | func Remove(name string) error {
lock.Lock()
defer lock.Unlock()
name = applyNamespace(name)
delete(griftList, name)
delete(descriptions, name)
return nil
} | [
"func",
"Remove",
"(",
"name",
"string",
")",
"error",
"{",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"name",
"=",
"applyNamespace",
"(",
"name",
")",
"\n\n",
"delete",
"(",
"griftList",
",",
"name",
")",
... | // Remove a grift. Not incredibly useful, but here for
// completeness. | [
"Remove",
"a",
"grift",
".",
"Not",
"incredibly",
"useful",
"but",
"here",
"for",
"completeness",
"."
] | ce869fe62d84875913170d186f91a34667e4c732 | https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/grift.go#L102-L111 |
55 | markbates/grift | grift/grift.go | Desc | func Desc(name string, description string) error {
lock.Lock()
defer lock.Unlock()
name = applyNamespace(name)
descriptions[name] = description
return nil
} | go | func Desc(name string, description string) error {
lock.Lock()
defer lock.Unlock()
name = applyNamespace(name)
descriptions[name] = description
return nil
} | [
"func",
"Desc",
"(",
"name",
"string",
",",
"description",
"string",
")",
"error",
"{",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"name",
"=",
"applyNamespace",
"(",
"name",
")",
"\n\n",
"descriptions",
"[",... | // Desc sets a helpful descriptive text for a grift.
// This description will be shown when `grift list`
// is run. | [
"Desc",
"sets",
"a",
"helpful",
"descriptive",
"text",
"for",
"a",
"grift",
".",
"This",
"description",
"will",
"be",
"shown",
"when",
"grift",
"list",
"is",
"run",
"."
] | ce869fe62d84875913170d186f91a34667e4c732 | https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/grift.go#L116-L124 |
56 | markbates/grift | grift/grift.go | Run | func Run(name string, c *Context) error {
name = applyNamespace(name)
if griftList[name] == nil {
if name == "list" {
PrintGrifts(os.Stdout)
return nil
}
return fmt.Errorf("No task named '%s' defined!", name)
}
if c.Verbose {
defer func(start time.Time) {
log.Printf("Completed task %s in %s\n", name, time.Now().Sub(start))
}(time.Now())
log.Printf("Starting task %s\n", name)
}
return griftList[name](c)
} | go | func Run(name string, c *Context) error {
name = applyNamespace(name)
if griftList[name] == nil {
if name == "list" {
PrintGrifts(os.Stdout)
return nil
}
return fmt.Errorf("No task named '%s' defined!", name)
}
if c.Verbose {
defer func(start time.Time) {
log.Printf("Completed task %s in %s\n", name, time.Now().Sub(start))
}(time.Now())
log.Printf("Starting task %s\n", name)
}
return griftList[name](c)
} | [
"func",
"Run",
"(",
"name",
"string",
",",
"c",
"*",
"Context",
")",
"error",
"{",
"name",
"=",
"applyNamespace",
"(",
"name",
")",
"\n\n",
"if",
"griftList",
"[",
"name",
"]",
"==",
"nil",
"{",
"if",
"name",
"==",
"\"",
"\"",
"{",
"PrintGrifts",
"... | // Run a grift. This allows for the chaining for grifts.
// One grift can Run another grift and so on. | [
"Run",
"a",
"grift",
".",
"This",
"allows",
"for",
"the",
"chaining",
"for",
"grifts",
".",
"One",
"grift",
"can",
"Run",
"another",
"grift",
"and",
"so",
"on",
"."
] | ce869fe62d84875913170d186f91a34667e4c732 | https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/grift.go#L128-L145 |
57 | markbates/grift | grift/grift.go | List | func List() []string {
keys := []string{}
for k := range griftList {
keys = append(keys, k)
}
sort.Strings(keys)
return keys
} | go | func List() []string {
keys := []string{}
for k := range griftList {
keys = append(keys, k)
}
sort.Strings(keys)
return keys
} | [
"func",
"List",
"(",
")",
"[",
"]",
"string",
"{",
"keys",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"k",
":=",
"range",
"griftList",
"{",
"keys",
"=",
"append",
"(",
"keys",
",",
"k",
")",
"\n",
"}",
"\n",
"sort",
".",
"Strings",
"(",
... | // List of the names of the defined grifts. | [
"List",
"of",
"the",
"names",
"of",
"the",
"defined",
"grifts",
"."
] | ce869fe62d84875913170d186f91a34667e4c732 | https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/grift.go#L148-L155 |
58 | markbates/grift | grift/grift.go | Exec | func Exec(args []string, verbose bool) error {
name := "list"
if len(args) >= 1 {
name = args[0]
}
switch name {
case "list":
PrintGrifts(os.Stdout)
default:
c := NewContext(name)
c.Verbose = verbose
if len(args) >= 1 {
c.Args = args[1:]
}
return Run(name, c)
}
return nil
} | go | func Exec(args []string, verbose bool) error {
name := "list"
if len(args) >= 1 {
name = args[0]
}
switch name {
case "list":
PrintGrifts(os.Stdout)
default:
c := NewContext(name)
c.Verbose = verbose
if len(args) >= 1 {
c.Args = args[1:]
}
return Run(name, c)
}
return nil
} | [
"func",
"Exec",
"(",
"args",
"[",
"]",
"string",
",",
"verbose",
"bool",
")",
"error",
"{",
"name",
":=",
"\"",
"\"",
"\n",
"if",
"len",
"(",
"args",
")",
">=",
"1",
"{",
"name",
"=",
"args",
"[",
"0",
"]",
"\n",
"}",
"\n",
"switch",
"name",
... | // Exec the grift stack. This is the main "entry point" to
// the grift system. | [
"Exec",
"the",
"grift",
"stack",
".",
"This",
"is",
"the",
"main",
"entry",
"point",
"to",
"the",
"grift",
"system",
"."
] | ce869fe62d84875913170d186f91a34667e4c732 | https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/grift.go#L159-L176 |
59 | markbates/grift | grift/grift.go | PrintGrifts | func PrintGrifts(w io.Writer) {
fmt.Fprint(w, "Available grifts\n================\n")
cnLen := len(CommandName)
maxLen := cnLen
l := List()
for _, k := range l {
if (len(k) + cnLen) > maxLen {
maxLen = len(k) + cnLen
}
}
for _, k := range l {
m := strings.Join([]string{CommandName, k}, " ")
suffix := strings.Repeat(" ", (maxLen+3)-len(m)) + " #"
fmt.Fprintln(w, strings.Join([]string{m, suffix, descriptions[k]}, " "))
}
} | go | func PrintGrifts(w io.Writer) {
fmt.Fprint(w, "Available grifts\n================\n")
cnLen := len(CommandName)
maxLen := cnLen
l := List()
for _, k := range l {
if (len(k) + cnLen) > maxLen {
maxLen = len(k) + cnLen
}
}
for _, k := range l {
m := strings.Join([]string{CommandName, k}, " ")
suffix := strings.Repeat(" ", (maxLen+3)-len(m)) + " #"
fmt.Fprintln(w, strings.Join([]string{m, suffix, descriptions[k]}, " "))
}
} | [
"func",
"PrintGrifts",
"(",
"w",
"io",
".",
"Writer",
")",
"{",
"fmt",
".",
"Fprint",
"(",
"w",
",",
"\"",
"\\n",
"\\n",
"\"",
")",
"\n\n",
"cnLen",
":=",
"len",
"(",
"CommandName",
")",
"\n",
"maxLen",
":=",
"cnLen",
"\n",
"l",
":=",
"List",
"("... | // PrintGrifts to the screen, nice, sorted, and with descriptions,
// should they exist. | [
"PrintGrifts",
"to",
"the",
"screen",
"nice",
"sorted",
"and",
"with",
"descriptions",
"should",
"they",
"exist",
"."
] | ce869fe62d84875913170d186f91a34667e4c732 | https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/grift.go#L180-L199 |
60 | markbates/grift | grift/context.go | Value | func (c *Context) Value(key interface{}) interface{} {
if s, ok := key.(string); ok {
if v, ok := c.data[s]; ok {
return v
}
}
return c.Context.Value(key)
} | go | func (c *Context) Value(key interface{}) interface{} {
if s, ok := key.(string); ok {
if v, ok := c.data[s]; ok {
return v
}
}
return c.Context.Value(key)
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"Value",
"(",
"key",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
"{",
"if",
"s",
",",
"ok",
":=",
"key",
".",
"(",
"string",
")",
";",
"ok",
"{",
"if",
"v",
",",
"ok",
":=",
"c",
".",
"data",
"[... | // Value returns a value from the context for the given key | [
"Value",
"returns",
"a",
"value",
"from",
"the",
"context",
"for",
"the",
"given",
"key"
] | ce869fe62d84875913170d186f91a34667e4c732 | https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/context.go#L19-L26 |
61 | markbates/grift | grift/context.go | Set | func (c *Context) Set(key string, val interface{}) {
c.moot.Lock()
defer c.moot.Unlock()
c.data[key] = val
} | go | func (c *Context) Set(key string, val interface{}) {
c.moot.Lock()
defer c.moot.Unlock()
c.data[key] = val
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"Set",
"(",
"key",
"string",
",",
"val",
"interface",
"{",
"}",
")",
"{",
"c",
".",
"moot",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"moot",
".",
"Unlock",
"(",
")",
"\n",
"c",
".",
"data",
"[",
... | // Set a piece of data onto the Context. | [
"Set",
"a",
"piece",
"of",
"data",
"onto",
"the",
"Context",
"."
] | ce869fe62d84875913170d186f91a34667e4c732 | https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/context.go#L29-L33 |
62 | markbates/grift | grift/context.go | NewContextWithContext | func NewContextWithContext(name string, ctx context.Context) *Context {
return &Context{
Context: ctx,
Name: name,
Args: []string{},
data: map[interface{}]interface{}{},
moot: &sync.Mutex{},
}
} | go | func NewContextWithContext(name string, ctx context.Context) *Context {
return &Context{
Context: ctx,
Name: name,
Args: []string{},
data: map[interface{}]interface{}{},
moot: &sync.Mutex{},
}
} | [
"func",
"NewContextWithContext",
"(",
"name",
"string",
",",
"ctx",
"context",
".",
"Context",
")",
"*",
"Context",
"{",
"return",
"&",
"Context",
"{",
"Context",
":",
"ctx",
",",
"Name",
":",
"name",
",",
"Args",
":",
"[",
"]",
"string",
"{",
"}",
"... | // NewContextWithContext builds and returns a new default Context given an existing context | [
"NewContextWithContext",
"builds",
"and",
"returns",
"a",
"new",
"default",
"Context",
"given",
"an",
"existing",
"context"
] | ce869fe62d84875913170d186f91a34667e4c732 | https://github.com/markbates/grift/blob/ce869fe62d84875913170d186f91a34667e4c732/grift/context.go#L41-L49 |
63 | aymerick/douceur | parser/parser.go | ParseStylesheet | func (parser *Parser) ParseStylesheet() (*css.Stylesheet, error) {
result := css.NewStylesheet()
// Parse BOM
if _, err := parser.parseBOM(); err != nil {
return result, err
}
// Parse list of rules
rules, err := parser.ParseRules()
if err != nil {
return result, err
}
result.Rules = rules
return result, nil
} | go | func (parser *Parser) ParseStylesheet() (*css.Stylesheet, error) {
result := css.NewStylesheet()
// Parse BOM
if _, err := parser.parseBOM(); err != nil {
return result, err
}
// Parse list of rules
rules, err := parser.ParseRules()
if err != nil {
return result, err
}
result.Rules = rules
return result, nil
} | [
"func",
"(",
"parser",
"*",
"Parser",
")",
"ParseStylesheet",
"(",
")",
"(",
"*",
"css",
".",
"Stylesheet",
",",
"error",
")",
"{",
"result",
":=",
"css",
".",
"NewStylesheet",
"(",
")",
"\n\n",
"// Parse BOM",
"if",
"_",
",",
"err",
":=",
"parser",
... | // ParseStylesheet parses a stylesheet | [
"ParseStylesheet",
"parses",
"a",
"stylesheet"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/parser/parser.go#L55-L72 |
64 | aymerick/douceur | parser/parser.go | ParseRules | func (parser *Parser) ParseRules() ([]*css.Rule, error) {
result := []*css.Rule{}
inBlock := false
if parser.tokenChar("{") {
// parsing a block of rules
inBlock = true
parser.embedLevel++
parser.shiftToken()
}
for parser.tokenParsable() {
if parser.tokenIgnorable() {
parser.shiftToken()
} else if parser.tokenChar("}") {
if !inBlock {
errMsg := fmt.Sprintf("Unexpected } character: %s", parser.nextToken().String())
return result, errors.New(errMsg)
}
parser.shiftToken()
parser.embedLevel--
// finished
break
} else {
rule, err := parser.ParseRule()
if err != nil {
return result, err
}
rule.EmbedLevel = parser.embedLevel
result = append(result, rule)
}
}
return result, parser.err()
} | go | func (parser *Parser) ParseRules() ([]*css.Rule, error) {
result := []*css.Rule{}
inBlock := false
if parser.tokenChar("{") {
// parsing a block of rules
inBlock = true
parser.embedLevel++
parser.shiftToken()
}
for parser.tokenParsable() {
if parser.tokenIgnorable() {
parser.shiftToken()
} else if parser.tokenChar("}") {
if !inBlock {
errMsg := fmt.Sprintf("Unexpected } character: %s", parser.nextToken().String())
return result, errors.New(errMsg)
}
parser.shiftToken()
parser.embedLevel--
// finished
break
} else {
rule, err := parser.ParseRule()
if err != nil {
return result, err
}
rule.EmbedLevel = parser.embedLevel
result = append(result, rule)
}
}
return result, parser.err()
} | [
"func",
"(",
"parser",
"*",
"Parser",
")",
"ParseRules",
"(",
")",
"(",
"[",
"]",
"*",
"css",
".",
"Rule",
",",
"error",
")",
"{",
"result",
":=",
"[",
"]",
"*",
"css",
".",
"Rule",
"{",
"}",
"\n\n",
"inBlock",
":=",
"false",
"\n",
"if",
"parse... | // ParseRules parses a list of rules | [
"ParseRules",
"parses",
"a",
"list",
"of",
"rules"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/parser/parser.go#L75-L113 |
65 | aymerick/douceur | parser/parser.go | ParseRule | func (parser *Parser) ParseRule() (*css.Rule, error) {
if parser.tokenAtKeyword() {
return parser.parseAtRule()
}
return parser.parseQualifiedRule()
} | go | func (parser *Parser) ParseRule() (*css.Rule, error) {
if parser.tokenAtKeyword() {
return parser.parseAtRule()
}
return parser.parseQualifiedRule()
} | [
"func",
"(",
"parser",
"*",
"Parser",
")",
"ParseRule",
"(",
")",
"(",
"*",
"css",
".",
"Rule",
",",
"error",
")",
"{",
"if",
"parser",
".",
"tokenAtKeyword",
"(",
")",
"{",
"return",
"parser",
".",
"parseAtRule",
"(",
")",
"\n",
"}",
"\n\n",
"retu... | // ParseRule parses a rule | [
"ParseRule",
"parses",
"a",
"rule"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/parser/parser.go#L116-L122 |
66 | aymerick/douceur | parser/parser.go | ParseDeclarations | func (parser *Parser) ParseDeclarations() ([]*css.Declaration, error) {
result := []*css.Declaration{}
if parser.tokenChar("{") {
parser.shiftToken()
}
for parser.tokenParsable() {
if parser.tokenIgnorable() {
parser.shiftToken()
} else if parser.tokenChar("}") {
// end of block
parser.shiftToken()
break
} else {
declaration, err := parser.ParseDeclaration()
if err != nil {
return result, err
}
result = append(result, declaration)
}
}
return result, parser.err()
} | go | func (parser *Parser) ParseDeclarations() ([]*css.Declaration, error) {
result := []*css.Declaration{}
if parser.tokenChar("{") {
parser.shiftToken()
}
for parser.tokenParsable() {
if parser.tokenIgnorable() {
parser.shiftToken()
} else if parser.tokenChar("}") {
// end of block
parser.shiftToken()
break
} else {
declaration, err := parser.ParseDeclaration()
if err != nil {
return result, err
}
result = append(result, declaration)
}
}
return result, parser.err()
} | [
"func",
"(",
"parser",
"*",
"Parser",
")",
"ParseDeclarations",
"(",
")",
"(",
"[",
"]",
"*",
"css",
".",
"Declaration",
",",
"error",
")",
"{",
"result",
":=",
"[",
"]",
"*",
"css",
".",
"Declaration",
"{",
"}",
"\n\n",
"if",
"parser",
".",
"token... | // ParseDeclarations parses a list of declarations | [
"ParseDeclarations",
"parses",
"a",
"list",
"of",
"declarations"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/parser/parser.go#L125-L150 |
67 | aymerick/douceur | parser/parser.go | ParseDeclaration | func (parser *Parser) ParseDeclaration() (*css.Declaration, error) {
result := css.NewDeclaration()
curValue := ""
for parser.tokenParsable() {
if parser.tokenChar(":") {
result.Property = strings.TrimSpace(curValue)
curValue = ""
parser.shiftToken()
} else if parser.tokenChar(";") || parser.tokenChar("}") {
if result.Property == "" {
errMsg := fmt.Sprintf("Unexpected ; character: %s", parser.nextToken().String())
return result, errors.New(errMsg)
}
if importantRegexp.MatchString(curValue) {
result.Important = true
curValue = importantRegexp.ReplaceAllString(curValue, "")
}
result.Value = strings.TrimSpace(curValue)
if parser.tokenChar(";") {
parser.shiftToken()
}
// finished
break
} else {
token := parser.shiftToken()
curValue += token.Value
}
}
// log.Printf("[parsed] Declaration: %s", result.String())
return result, parser.err()
} | go | func (parser *Parser) ParseDeclaration() (*css.Declaration, error) {
result := css.NewDeclaration()
curValue := ""
for parser.tokenParsable() {
if parser.tokenChar(":") {
result.Property = strings.TrimSpace(curValue)
curValue = ""
parser.shiftToken()
} else if parser.tokenChar(";") || parser.tokenChar("}") {
if result.Property == "" {
errMsg := fmt.Sprintf("Unexpected ; character: %s", parser.nextToken().String())
return result, errors.New(errMsg)
}
if importantRegexp.MatchString(curValue) {
result.Important = true
curValue = importantRegexp.ReplaceAllString(curValue, "")
}
result.Value = strings.TrimSpace(curValue)
if parser.tokenChar(";") {
parser.shiftToken()
}
// finished
break
} else {
token := parser.shiftToken()
curValue += token.Value
}
}
// log.Printf("[parsed] Declaration: %s", result.String())
return result, parser.err()
} | [
"func",
"(",
"parser",
"*",
"Parser",
")",
"ParseDeclaration",
"(",
")",
"(",
"*",
"css",
".",
"Declaration",
",",
"error",
")",
"{",
"result",
":=",
"css",
".",
"NewDeclaration",
"(",
")",
"\n",
"curValue",
":=",
"\"",
"\"",
"\n\n",
"for",
"parser",
... | // ParseDeclaration parses a declaration | [
"ParseDeclaration",
"parses",
"a",
"declaration"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/parser/parser.go#L153-L191 |
68 | aymerick/douceur | parser/parser.go | parseAtRule | func (parser *Parser) parseAtRule() (*css.Rule, error) {
// parse rule name (eg: "@import")
token := parser.shiftToken()
result := css.NewRule(css.AtRule)
result.Name = token.Value
for parser.tokenParsable() {
if parser.tokenChar(";") {
parser.shiftToken()
// finished
break
} else if parser.tokenChar("{") {
if result.EmbedsRules() {
// parse rules block
rules, err := parser.ParseRules()
if err != nil {
return result, err
}
result.Rules = rules
} else {
// parse declarations block
declarations, err := parser.ParseDeclarations()
if err != nil {
return result, err
}
result.Declarations = declarations
}
// finished
break
} else {
// parse prelude
prelude, err := parser.parsePrelude()
if err != nil {
return result, err
}
result.Prelude = prelude
}
}
// log.Printf("[parsed] Rule: %s", result.String())
return result, parser.err()
} | go | func (parser *Parser) parseAtRule() (*css.Rule, error) {
// parse rule name (eg: "@import")
token := parser.shiftToken()
result := css.NewRule(css.AtRule)
result.Name = token.Value
for parser.tokenParsable() {
if parser.tokenChar(";") {
parser.shiftToken()
// finished
break
} else if parser.tokenChar("{") {
if result.EmbedsRules() {
// parse rules block
rules, err := parser.ParseRules()
if err != nil {
return result, err
}
result.Rules = rules
} else {
// parse declarations block
declarations, err := parser.ParseDeclarations()
if err != nil {
return result, err
}
result.Declarations = declarations
}
// finished
break
} else {
// parse prelude
prelude, err := parser.parsePrelude()
if err != nil {
return result, err
}
result.Prelude = prelude
}
}
// log.Printf("[parsed] Rule: %s", result.String())
return result, parser.err()
} | [
"func",
"(",
"parser",
"*",
"Parser",
")",
"parseAtRule",
"(",
")",
"(",
"*",
"css",
".",
"Rule",
",",
"error",
")",
"{",
"// parse rule name (eg: \"@import\")",
"token",
":=",
"parser",
".",
"shiftToken",
"(",
")",
"\n\n",
"result",
":=",
"css",
".",
"N... | // Parse an At Rule | [
"Parse",
"an",
"At",
"Rule"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/parser/parser.go#L194-L242 |
69 | aymerick/douceur | parser/parser.go | parseQualifiedRule | func (parser *Parser) parseQualifiedRule() (*css.Rule, error) {
result := css.NewRule(css.QualifiedRule)
for parser.tokenParsable() {
if parser.tokenChar("{") {
if result.Prelude == "" {
errMsg := fmt.Sprintf("Unexpected { character: %s", parser.nextToken().String())
return result, errors.New(errMsg)
}
// parse declarations block
declarations, err := parser.ParseDeclarations()
if err != nil {
return result, err
}
result.Declarations = declarations
// finished
break
} else {
// parse prelude
prelude, err := parser.parsePrelude()
if err != nil {
return result, err
}
result.Prelude = prelude
}
}
result.Selectors = strings.Split(result.Prelude, ",")
for i, sel := range result.Selectors {
result.Selectors[i] = strings.TrimSpace(sel)
}
// log.Printf("[parsed] Rule: %s", result.String())
return result, parser.err()
} | go | func (parser *Parser) parseQualifiedRule() (*css.Rule, error) {
result := css.NewRule(css.QualifiedRule)
for parser.tokenParsable() {
if parser.tokenChar("{") {
if result.Prelude == "" {
errMsg := fmt.Sprintf("Unexpected { character: %s", parser.nextToken().String())
return result, errors.New(errMsg)
}
// parse declarations block
declarations, err := parser.ParseDeclarations()
if err != nil {
return result, err
}
result.Declarations = declarations
// finished
break
} else {
// parse prelude
prelude, err := parser.parsePrelude()
if err != nil {
return result, err
}
result.Prelude = prelude
}
}
result.Selectors = strings.Split(result.Prelude, ",")
for i, sel := range result.Selectors {
result.Selectors[i] = strings.TrimSpace(sel)
}
// log.Printf("[parsed] Rule: %s", result.String())
return result, parser.err()
} | [
"func",
"(",
"parser",
"*",
"Parser",
")",
"parseQualifiedRule",
"(",
")",
"(",
"*",
"css",
".",
"Rule",
",",
"error",
")",
"{",
"result",
":=",
"css",
".",
"NewRule",
"(",
"css",
".",
"QualifiedRule",
")",
"\n\n",
"for",
"parser",
".",
"tokenParsable"... | // Parse a Qualified Rule | [
"Parse",
"a",
"Qualified",
"Rule"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/parser/parser.go#L245-L284 |
70 | aymerick/douceur | parser/parser.go | parsePrelude | func (parser *Parser) parsePrelude() (string, error) {
result := ""
for parser.tokenParsable() && !parser.tokenEndOfPrelude() {
token := parser.shiftToken()
result += token.Value
}
result = strings.TrimSpace(result)
// log.Printf("[parsed] prelude: %s", result)
return result, parser.err()
} | go | func (parser *Parser) parsePrelude() (string, error) {
result := ""
for parser.tokenParsable() && !parser.tokenEndOfPrelude() {
token := parser.shiftToken()
result += token.Value
}
result = strings.TrimSpace(result)
// log.Printf("[parsed] prelude: %s", result)
return result, parser.err()
} | [
"func",
"(",
"parser",
"*",
"Parser",
")",
"parsePrelude",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"result",
":=",
"\"",
"\"",
"\n\n",
"for",
"parser",
".",
"tokenParsable",
"(",
")",
"&&",
"!",
"parser",
".",
"tokenEndOfPrelude",
"(",
")",
... | // Parse Rule prelude | [
"Parse",
"Rule",
"prelude"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/parser/parser.go#L287-L300 |
71 | aymerick/douceur | parser/parser.go | nextToken | func (parser *Parser) nextToken() *scanner.Token {
if len(parser.tokens) == 0 {
// fetch next token
nextToken := parser.scan.Next()
// log.Printf("[token] %s => %v", nextToken.Type.String(), nextToken.Value)
// queue it
parser.tokens = append(parser.tokens, nextToken)
}
return parser.tokens[0]
} | go | func (parser *Parser) nextToken() *scanner.Token {
if len(parser.tokens) == 0 {
// fetch next token
nextToken := parser.scan.Next()
// log.Printf("[token] %s => %v", nextToken.Type.String(), nextToken.Value)
// queue it
parser.tokens = append(parser.tokens, nextToken)
}
return parser.tokens[0]
} | [
"func",
"(",
"parser",
"*",
"Parser",
")",
"nextToken",
"(",
")",
"*",
"scanner",
".",
"Token",
"{",
"if",
"len",
"(",
"parser",
".",
"tokens",
")",
"==",
"0",
"{",
"// fetch next token",
"nextToken",
":=",
"parser",
".",
"scan",
".",
"Next",
"(",
")... | // Returns next token without removing it from tokens buffer | [
"Returns",
"next",
"token",
"without",
"removing",
"it",
"from",
"tokens",
"buffer"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/parser/parser.go#L313-L325 |
72 | aymerick/douceur | parser/parser.go | shiftToken | func (parser *Parser) shiftToken() *scanner.Token {
var result *scanner.Token
result, parser.tokens = parser.tokens[0], parser.tokens[1:]
return result
} | go | func (parser *Parser) shiftToken() *scanner.Token {
var result *scanner.Token
result, parser.tokens = parser.tokens[0], parser.tokens[1:]
return result
} | [
"func",
"(",
"parser",
"*",
"Parser",
")",
"shiftToken",
"(",
")",
"*",
"scanner",
".",
"Token",
"{",
"var",
"result",
"*",
"scanner",
".",
"Token",
"\n\n",
"result",
",",
"parser",
".",
"tokens",
"=",
"parser",
".",
"tokens",
"[",
"0",
"]",
",",
"... | // Returns next token and remove it from the tokens buffer | [
"Returns",
"next",
"token",
"and",
"remove",
"it",
"from",
"the",
"tokens",
"buffer"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/parser/parser.go#L328-L333 |
73 | aymerick/douceur | parser/parser.go | err | func (parser *Parser) err() error {
if parser.tokenError() {
token := parser.nextToken()
return fmt.Errorf("Tokenizer error: %s", token.String())
}
return nil
} | go | func (parser *Parser) err() error {
if parser.tokenError() {
token := parser.nextToken()
return fmt.Errorf("Tokenizer error: %s", token.String())
}
return nil
} | [
"func",
"(",
"parser",
"*",
"Parser",
")",
"err",
"(",
")",
"error",
"{",
"if",
"parser",
".",
"tokenError",
"(",
")",
"{",
"token",
":=",
"parser",
".",
"nextToken",
"(",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"token",
... | // Returns tokenizer error, or nil if no error | [
"Returns",
"tokenizer",
"error",
"or",
"nil",
"if",
"no",
"error"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/parser/parser.go#L336-L343 |
74 | aymerick/douceur | parser/parser.go | tokenCDOorCDC | func (parser *Parser) tokenCDOorCDC() bool {
switch parser.nextToken().Type {
case scanner.TokenCDO, scanner.TokenCDC:
return true
default:
return false
}
} | go | func (parser *Parser) tokenCDOorCDC() bool {
switch parser.nextToken().Type {
case scanner.TokenCDO, scanner.TokenCDC:
return true
default:
return false
}
} | [
"func",
"(",
"parser",
"*",
"Parser",
")",
"tokenCDOorCDC",
"(",
")",
"bool",
"{",
"switch",
"parser",
".",
"nextToken",
"(",
")",
".",
"Type",
"{",
"case",
"scanner",
".",
"TokenCDO",
",",
"scanner",
".",
"TokenCDC",
":",
"return",
"true",
"\n",
"defa... | // Returns true if next token is a CDO or a CDC | [
"Returns",
"true",
"if",
"next",
"token",
"is",
"a",
"CDO",
"or",
"a",
"CDC"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/parser/parser.go#L366-L373 |
75 | aymerick/douceur | parser/parser.go | tokenIgnorable | func (parser *Parser) tokenIgnorable() bool {
return parser.tokenWS() || parser.tokenComment() || parser.tokenCDOorCDC()
} | go | func (parser *Parser) tokenIgnorable() bool {
return parser.tokenWS() || parser.tokenComment() || parser.tokenCDOorCDC()
} | [
"func",
"(",
"parser",
"*",
"Parser",
")",
"tokenIgnorable",
"(",
")",
"bool",
"{",
"return",
"parser",
".",
"tokenWS",
"(",
")",
"||",
"parser",
".",
"tokenComment",
"(",
")",
"||",
"parser",
".",
"tokenCDOorCDC",
"(",
")",
"\n",
"}"
] | // Returns true if next token is ignorable | [
"Returns",
"true",
"if",
"next",
"token",
"is",
"ignorable"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/parser/parser.go#L376-L378 |
76 | aymerick/douceur | parser/parser.go | tokenChar | func (parser *Parser) tokenChar(value string) bool {
token := parser.nextToken()
return (token.Type == scanner.TokenChar) && (token.Value == value)
} | go | func (parser *Parser) tokenChar(value string) bool {
token := parser.nextToken()
return (token.Type == scanner.TokenChar) && (token.Value == value)
} | [
"func",
"(",
"parser",
"*",
"Parser",
")",
"tokenChar",
"(",
"value",
"string",
")",
"bool",
"{",
"token",
":=",
"parser",
".",
"nextToken",
"(",
")",
"\n",
"return",
"(",
"token",
".",
"Type",
"==",
"scanner",
".",
"TokenChar",
")",
"&&",
"(",
"toke... | // Returns true if next token is given character | [
"Returns",
"true",
"if",
"next",
"token",
"is",
"given",
"character"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/parser/parser.go#L391-L394 |
77 | aymerick/douceur | css/stylesheet.go | String | func (sheet *Stylesheet) String() string {
result := ""
for _, rule := range sheet.Rules {
if result != "" {
result += "\n"
}
result += rule.String()
}
return result
} | go | func (sheet *Stylesheet) String() string {
result := ""
for _, rule := range sheet.Rules {
if result != "" {
result += "\n"
}
result += rule.String()
}
return result
} | [
"func",
"(",
"sheet",
"*",
"Stylesheet",
")",
"String",
"(",
")",
"string",
"{",
"result",
":=",
"\"",
"\"",
"\n\n",
"for",
"_",
",",
"rule",
":=",
"range",
"sheet",
".",
"Rules",
"{",
"if",
"result",
"!=",
"\"",
"\"",
"{",
"result",
"+=",
"\"",
... | // Returns string representation of the Stylesheet | [
"Returns",
"string",
"representation",
"of",
"the",
"Stylesheet"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/css/stylesheet.go#L14-L25 |
78 | aymerick/douceur | css/rule.go | EmbedsRules | func (rule *Rule) EmbedsRules() bool {
if rule.Kind == AtRule {
for _, atRuleName := range atRulesWithRulesBlock {
if rule.Name == atRuleName {
return true
}
}
}
return false
} | go | func (rule *Rule) EmbedsRules() bool {
if rule.Kind == AtRule {
for _, atRuleName := range atRulesWithRulesBlock {
if rule.Name == atRuleName {
return true
}
}
}
return false
} | [
"func",
"(",
"rule",
"*",
"Rule",
")",
"EmbedsRules",
"(",
")",
"bool",
"{",
"if",
"rule",
".",
"Kind",
"==",
"AtRule",
"{",
"for",
"_",
",",
"atRuleName",
":=",
"range",
"atRulesWithRulesBlock",
"{",
"if",
"rule",
".",
"Name",
"==",
"atRuleName",
"{",... | // EmbedsRules returns true if this rule embeds another rules | [
"EmbedsRules",
"returns",
"true",
"if",
"this",
"rule",
"embeds",
"another",
"rules"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/css/rule.go#L69-L79 |
79 | aymerick/douceur | css/rule.go | Equal | func (rule *Rule) Equal(other *Rule) bool {
if (rule.Kind != other.Kind) ||
(rule.Prelude != other.Prelude) ||
(rule.Name != other.Name) {
return false
}
if (len(rule.Selectors) != len(other.Selectors)) ||
(len(rule.Declarations) != len(other.Declarations)) ||
(len(rule.Rules) != len(other.Rules)) {
return false
}
for i, sel := range rule.Selectors {
if sel != other.Selectors[i] {
return false
}
}
for i, decl := range rule.Declarations {
if !decl.Equal(other.Declarations[i]) {
return false
}
}
for i, rule := range rule.Rules {
if !rule.Equal(other.Rules[i]) {
return false
}
}
return true
} | go | func (rule *Rule) Equal(other *Rule) bool {
if (rule.Kind != other.Kind) ||
(rule.Prelude != other.Prelude) ||
(rule.Name != other.Name) {
return false
}
if (len(rule.Selectors) != len(other.Selectors)) ||
(len(rule.Declarations) != len(other.Declarations)) ||
(len(rule.Rules) != len(other.Rules)) {
return false
}
for i, sel := range rule.Selectors {
if sel != other.Selectors[i] {
return false
}
}
for i, decl := range rule.Declarations {
if !decl.Equal(other.Declarations[i]) {
return false
}
}
for i, rule := range rule.Rules {
if !rule.Equal(other.Rules[i]) {
return false
}
}
return true
} | [
"func",
"(",
"rule",
"*",
"Rule",
")",
"Equal",
"(",
"other",
"*",
"Rule",
")",
"bool",
"{",
"if",
"(",
"rule",
".",
"Kind",
"!=",
"other",
".",
"Kind",
")",
"||",
"(",
"rule",
".",
"Prelude",
"!=",
"other",
".",
"Prelude",
")",
"||",
"(",
"rul... | // Equal returns true if both rules are equals | [
"Equal",
"returns",
"true",
"if",
"both",
"rules",
"are",
"equals"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/css/rule.go#L82-L114 |
80 | aymerick/douceur | css/rule.go | Diff | func (rule *Rule) Diff(other *Rule) []string {
result := []string{}
if rule.Kind != other.Kind {
result = append(result, fmt.Sprintf("Kind: %s | %s", rule.Kind.String(), other.Kind.String()))
}
if rule.Prelude != other.Prelude {
result = append(result, fmt.Sprintf("Prelude: \"%s\" | \"%s\"", rule.Prelude, other.Prelude))
}
if rule.Name != other.Name {
result = append(result, fmt.Sprintf("Name: \"%s\" | \"%s\"", rule.Name, other.Name))
}
if len(rule.Selectors) != len(other.Selectors) {
result = append(result, fmt.Sprintf("Selectors: %v | %v", strings.Join(rule.Selectors, ", "), strings.Join(other.Selectors, ", ")))
} else {
for i, sel := range rule.Selectors {
if sel != other.Selectors[i] {
result = append(result, fmt.Sprintf("Selector: \"%s\" | \"%s\"", sel, other.Selectors[i]))
}
}
}
if len(rule.Declarations) != len(other.Declarations) {
result = append(result, fmt.Sprintf("Declarations Nb: %d | %d", len(rule.Declarations), len(other.Declarations)))
} else {
for i, decl := range rule.Declarations {
if !decl.Equal(other.Declarations[i]) {
result = append(result, fmt.Sprintf("Declaration: \"%s\" | \"%s\"", decl.String(), other.Declarations[i].String()))
}
}
}
if len(rule.Rules) != len(other.Rules) {
result = append(result, fmt.Sprintf("Rules Nb: %d | %d", len(rule.Rules), len(other.Rules)))
} else {
for i, rule := range rule.Rules {
if !rule.Equal(other.Rules[i]) {
result = append(result, fmt.Sprintf("Rule: \"%s\" | \"%s\"", rule.String(), other.Rules[i].String()))
}
}
}
return result
} | go | func (rule *Rule) Diff(other *Rule) []string {
result := []string{}
if rule.Kind != other.Kind {
result = append(result, fmt.Sprintf("Kind: %s | %s", rule.Kind.String(), other.Kind.String()))
}
if rule.Prelude != other.Prelude {
result = append(result, fmt.Sprintf("Prelude: \"%s\" | \"%s\"", rule.Prelude, other.Prelude))
}
if rule.Name != other.Name {
result = append(result, fmt.Sprintf("Name: \"%s\" | \"%s\"", rule.Name, other.Name))
}
if len(rule.Selectors) != len(other.Selectors) {
result = append(result, fmt.Sprintf("Selectors: %v | %v", strings.Join(rule.Selectors, ", "), strings.Join(other.Selectors, ", ")))
} else {
for i, sel := range rule.Selectors {
if sel != other.Selectors[i] {
result = append(result, fmt.Sprintf("Selector: \"%s\" | \"%s\"", sel, other.Selectors[i]))
}
}
}
if len(rule.Declarations) != len(other.Declarations) {
result = append(result, fmt.Sprintf("Declarations Nb: %d | %d", len(rule.Declarations), len(other.Declarations)))
} else {
for i, decl := range rule.Declarations {
if !decl.Equal(other.Declarations[i]) {
result = append(result, fmt.Sprintf("Declaration: \"%s\" | \"%s\"", decl.String(), other.Declarations[i].String()))
}
}
}
if len(rule.Rules) != len(other.Rules) {
result = append(result, fmt.Sprintf("Rules Nb: %d | %d", len(rule.Rules), len(other.Rules)))
} else {
for i, rule := range rule.Rules {
if !rule.Equal(other.Rules[i]) {
result = append(result, fmt.Sprintf("Rule: \"%s\" | \"%s\"", rule.String(), other.Rules[i].String()))
}
}
}
return result
} | [
"func",
"(",
"rule",
"*",
"Rule",
")",
"Diff",
"(",
"other",
"*",
"Rule",
")",
"[",
"]",
"string",
"{",
"result",
":=",
"[",
"]",
"string",
"{",
"}",
"\n\n",
"if",
"rule",
".",
"Kind",
"!=",
"other",
".",
"Kind",
"{",
"result",
"=",
"append",
"... | // Diff returns a string representation of rules differences | [
"Diff",
"returns",
"a",
"string",
"representation",
"of",
"rules",
"differences"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/css/rule.go#L117-L164 |
81 | aymerick/douceur | css/rule.go | String | func (rule *Rule) String() string {
result := ""
if rule.Kind == QualifiedRule {
for i, sel := range rule.Selectors {
if i != 0 {
result += ", "
}
result += sel
}
} else {
// AtRule
result += fmt.Sprintf("%s", rule.Name)
if rule.Prelude != "" {
if result != "" {
result += " "
}
result += fmt.Sprintf("%s", rule.Prelude)
}
}
if (len(rule.Declarations) == 0) && (len(rule.Rules) == 0) {
result += ";"
} else {
result += " {\n"
if rule.EmbedsRules() {
for _, subRule := range rule.Rules {
result += fmt.Sprintf("%s%s\n", rule.indent(), subRule.String())
}
} else {
for _, decl := range rule.Declarations {
result += fmt.Sprintf("%s%s\n", rule.indent(), decl.String())
}
}
result += fmt.Sprintf("%s}", rule.indentEndBlock())
}
return result
} | go | func (rule *Rule) String() string {
result := ""
if rule.Kind == QualifiedRule {
for i, sel := range rule.Selectors {
if i != 0 {
result += ", "
}
result += sel
}
} else {
// AtRule
result += fmt.Sprintf("%s", rule.Name)
if rule.Prelude != "" {
if result != "" {
result += " "
}
result += fmt.Sprintf("%s", rule.Prelude)
}
}
if (len(rule.Declarations) == 0) && (len(rule.Rules) == 0) {
result += ";"
} else {
result += " {\n"
if rule.EmbedsRules() {
for _, subRule := range rule.Rules {
result += fmt.Sprintf("%s%s\n", rule.indent(), subRule.String())
}
} else {
for _, decl := range rule.Declarations {
result += fmt.Sprintf("%s%s\n", rule.indent(), decl.String())
}
}
result += fmt.Sprintf("%s}", rule.indentEndBlock())
}
return result
} | [
"func",
"(",
"rule",
"*",
"Rule",
")",
"String",
"(",
")",
"string",
"{",
"result",
":=",
"\"",
"\"",
"\n\n",
"if",
"rule",
".",
"Kind",
"==",
"QualifiedRule",
"{",
"for",
"i",
",",
"sel",
":=",
"range",
"rule",
".",
"Selectors",
"{",
"if",
"i",
... | // Returns the string representation of a rule | [
"Returns",
"the",
"string",
"representation",
"of",
"a",
"rule"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/css/rule.go#L167-L208 |
82 | aymerick/douceur | css/rule.go | indent | func (rule *Rule) indent() string {
result := ""
for i := 0; i < ((rule.EmbedLevel + 1) * indentSpace); i++ {
result += " "
}
return result
} | go | func (rule *Rule) indent() string {
result := ""
for i := 0; i < ((rule.EmbedLevel + 1) * indentSpace); i++ {
result += " "
}
return result
} | [
"func",
"(",
"rule",
"*",
"Rule",
")",
"indent",
"(",
")",
"string",
"{",
"result",
":=",
"\"",
"\"",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"(",
"(",
"rule",
".",
"EmbedLevel",
"+",
"1",
")",
"*",
"indentSpace",
")",
";",
"i",
"++",
"... | // Returns identation spaces for declarations and rules | [
"Returns",
"identation",
"spaces",
"for",
"declarations",
"and",
"rules"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/css/rule.go#L211-L219 |
83 | aymerick/douceur | css/rule.go | indentEndBlock | func (rule *Rule) indentEndBlock() string {
result := ""
for i := 0; i < (rule.EmbedLevel * indentSpace); i++ {
result += " "
}
return result
} | go | func (rule *Rule) indentEndBlock() string {
result := ""
for i := 0; i < (rule.EmbedLevel * indentSpace); i++ {
result += " "
}
return result
} | [
"func",
"(",
"rule",
"*",
"Rule",
")",
"indentEndBlock",
"(",
")",
"string",
"{",
"result",
":=",
"\"",
"\"",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"(",
"rule",
".",
"EmbedLevel",
"*",
"indentSpace",
")",
";",
"i",
"++",
"{",
"result",
"+... | // Returns identation spaces for end of block character | [
"Returns",
"identation",
"spaces",
"for",
"end",
"of",
"block",
"character"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/css/rule.go#L222-L230 |
84 | aymerick/douceur | douceur.go | parseCSS | func parseCSS(filePath string) {
input := readFile(filePath)
stylesheet, err := parser.Parse(string(input))
if err != nil {
fmt.Println("Parsing error: ", err)
os.Exit(1)
}
fmt.Println(stylesheet.String())
} | go | func parseCSS(filePath string) {
input := readFile(filePath)
stylesheet, err := parser.Parse(string(input))
if err != nil {
fmt.Println("Parsing error: ", err)
os.Exit(1)
}
fmt.Println(stylesheet.String())
} | [
"func",
"parseCSS",
"(",
"filePath",
"string",
")",
"{",
"input",
":=",
"readFile",
"(",
"filePath",
")",
"\n\n",
"stylesheet",
",",
"err",
":=",
"parser",
".",
"Parse",
"(",
"string",
"(",
"input",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt... | // parse and display CSS file | [
"parse",
"and",
"display",
"CSS",
"file"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/douceur.go#L63-L73 |
85 | aymerick/douceur | douceur.go | inlineCSS | func inlineCSS(filePath string) {
input := readFile(filePath)
output, err := inliner.Inline(string(input))
if err != nil {
fmt.Println("Inlining error: ", err)
os.Exit(1)
}
fmt.Println(output)
} | go | func inlineCSS(filePath string) {
input := readFile(filePath)
output, err := inliner.Inline(string(input))
if err != nil {
fmt.Println("Inlining error: ", err)
os.Exit(1)
}
fmt.Println(output)
} | [
"func",
"inlineCSS",
"(",
"filePath",
"string",
")",
"{",
"input",
":=",
"readFile",
"(",
"filePath",
")",
"\n\n",
"output",
",",
"err",
":=",
"inliner",
".",
"Inline",
"(",
"string",
"(",
"input",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt"... | // inlines CSS into HTML and display result | [
"inlines",
"CSS",
"into",
"HTML",
"and",
"display",
"result"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/douceur.go#L76-L86 |
86 | aymerick/douceur | inliner/element.go | addStyleRule | func (element *Element) addStyleRule(styleRule *StyleRule) {
element.styleRules = append(element.styleRules, styleRule)
} | go | func (element *Element) addStyleRule(styleRule *StyleRule) {
element.styleRules = append(element.styleRules, styleRule)
} | [
"func",
"(",
"element",
"*",
"Element",
")",
"addStyleRule",
"(",
"styleRule",
"*",
"StyleRule",
")",
"{",
"element",
".",
"styleRules",
"=",
"append",
"(",
"element",
".",
"styleRules",
",",
"styleRule",
")",
"\n",
"}"
] | // Add a Style Rule to Element | [
"Add",
"a",
"Style",
"Rule",
"to",
"Element"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/inliner/element.go#L66-L68 |
87 | aymerick/douceur | inliner/element.go | inline | func (element *Element) inline() error {
// compute declarations
declarations, err := element.computeDeclarations()
if err != nil {
return err
}
// set style attribute
styleValue := computeStyleValue(declarations)
if styleValue != "" {
element.elt.SetAttr("style", styleValue)
}
// set additionnal attributes
element.setAttributesFromStyle(declarations)
return nil
} | go | func (element *Element) inline() error {
// compute declarations
declarations, err := element.computeDeclarations()
if err != nil {
return err
}
// set style attribute
styleValue := computeStyleValue(declarations)
if styleValue != "" {
element.elt.SetAttr("style", styleValue)
}
// set additionnal attributes
element.setAttributesFromStyle(declarations)
return nil
} | [
"func",
"(",
"element",
"*",
"Element",
")",
"inline",
"(",
")",
"error",
"{",
"// compute declarations",
"declarations",
",",
"err",
":=",
"element",
".",
"computeDeclarations",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
... | // Inline styles on element | [
"Inline",
"styles",
"on",
"element"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/inliner/element.go#L71-L88 |
88 | aymerick/douceur | inliner/element.go | computeDeclarations | func (element *Element) computeDeclarations() ([]*css.Declaration, error) {
result := []*css.Declaration{}
styles := make(map[string]*StyleDeclaration)
// First: parsed stylesheets rules
mergeStyleDeclarations(element.styleRules, styles)
// Then: inline rules
inlineRules, err := element.parseInlineStyle()
if err != nil {
return result, err
}
mergeStyleDeclarations(inlineRules, styles)
// map to array
for _, styleDecl := range styles {
result = append(result, styleDecl.Declaration)
}
// sort declarations by property name
sort.Sort(css.DeclarationsByProperty(result))
return result, nil
} | go | func (element *Element) computeDeclarations() ([]*css.Declaration, error) {
result := []*css.Declaration{}
styles := make(map[string]*StyleDeclaration)
// First: parsed stylesheets rules
mergeStyleDeclarations(element.styleRules, styles)
// Then: inline rules
inlineRules, err := element.parseInlineStyle()
if err != nil {
return result, err
}
mergeStyleDeclarations(inlineRules, styles)
// map to array
for _, styleDecl := range styles {
result = append(result, styleDecl.Declaration)
}
// sort declarations by property name
sort.Sort(css.DeclarationsByProperty(result))
return result, nil
} | [
"func",
"(",
"element",
"*",
"Element",
")",
"computeDeclarations",
"(",
")",
"(",
"[",
"]",
"*",
"css",
".",
"Declaration",
",",
"error",
")",
"{",
"result",
":=",
"[",
"]",
"*",
"css",
".",
"Declaration",
"{",
"}",
"\n\n",
"styles",
":=",
"make",
... | // Compute css declarations | [
"Compute",
"css",
"declarations"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/inliner/element.go#L91-L116 |
89 | aymerick/douceur | inliner/element.go | parseInlineStyle | func (element *Element) parseInlineStyle() ([]*StyleRule, error) {
result := []*StyleRule{}
styleValue, exists := element.elt.Attr("style")
if (styleValue == "") || !exists {
return result, nil
}
declarations, err := parser.ParseDeclarations(styleValue)
if err != nil {
return result, err
}
result = append(result, NewStyleRule(inlineFakeSelector, declarations))
return result, nil
} | go | func (element *Element) parseInlineStyle() ([]*StyleRule, error) {
result := []*StyleRule{}
styleValue, exists := element.elt.Attr("style")
if (styleValue == "") || !exists {
return result, nil
}
declarations, err := parser.ParseDeclarations(styleValue)
if err != nil {
return result, err
}
result = append(result, NewStyleRule(inlineFakeSelector, declarations))
return result, nil
} | [
"func",
"(",
"element",
"*",
"Element",
")",
"parseInlineStyle",
"(",
")",
"(",
"[",
"]",
"*",
"StyleRule",
",",
"error",
")",
"{",
"result",
":=",
"[",
"]",
"*",
"StyleRule",
"{",
"}",
"\n\n",
"styleValue",
",",
"exists",
":=",
"element",
".",
"elt"... | // Parse inline style rules | [
"Parse",
"inline",
"style",
"rules"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/inliner/element.go#L119-L135 |
90 | aymerick/douceur | inliner/element.go | setAttributesFromStyle | func (element *Element) setAttributesFromStyle(declarations []*css.Declaration) {
// for each style declarations
for _, declaration := range declarations {
if eltAttr := styleToAttr[declaration.Property]; eltAttr != nil {
// check if element is allowed for that attribute
for _, eltAllowed := range eltAttr.elements {
if element.elt.Nodes[0].Data == eltAllowed {
element.elt.SetAttr(eltAttr.attr, declaration.Value)
break
}
}
}
}
} | go | func (element *Element) setAttributesFromStyle(declarations []*css.Declaration) {
// for each style declarations
for _, declaration := range declarations {
if eltAttr := styleToAttr[declaration.Property]; eltAttr != nil {
// check if element is allowed for that attribute
for _, eltAllowed := range eltAttr.elements {
if element.elt.Nodes[0].Data == eltAllowed {
element.elt.SetAttr(eltAttr.attr, declaration.Value)
break
}
}
}
}
} | [
"func",
"(",
"element",
"*",
"Element",
")",
"setAttributesFromStyle",
"(",
"declarations",
"[",
"]",
"*",
"css",
".",
"Declaration",
")",
"{",
"// for each style declarations",
"for",
"_",
",",
"declaration",
":=",
"range",
"declarations",
"{",
"if",
"eltAttr",... | // Set additional attributes from style declarations | [
"Set",
"additional",
"attributes",
"from",
"style",
"declarations"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/inliner/element.go#L138-L152 |
91 | aymerick/douceur | inliner/style_rule.go | NewStyleRule | func NewStyleRule(selector string, declarations []*css.Declaration) *StyleRule {
return &StyleRule{
Selector: selector,
Declarations: declarations,
Specificity: ComputeSpecificity(selector),
}
} | go | func NewStyleRule(selector string, declarations []*css.Declaration) *StyleRule {
return &StyleRule{
Selector: selector,
Declarations: declarations,
Specificity: ComputeSpecificity(selector),
}
} | [
"func",
"NewStyleRule",
"(",
"selector",
"string",
",",
"declarations",
"[",
"]",
"*",
"css",
".",
"Declaration",
")",
"*",
"StyleRule",
"{",
"return",
"&",
"StyleRule",
"{",
"Selector",
":",
"selector",
",",
"Declarations",
":",
"declarations",
",",
"Specif... | // NewStyleRule instanciates a new StyleRule | [
"NewStyleRule",
"instanciates",
"a",
"new",
"StyleRule"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/inliner/style_rule.go#L43-L49 |
92 | aymerick/douceur | inliner/style_rule.go | String | func (styleRule *StyleRule) String() string {
result := ""
result += styleRule.Selector
if len(styleRule.Declarations) == 0 {
result += ";"
} else {
result += " {\n"
for _, decl := range styleRule.Declarations {
result += fmt.Sprintf(" %s\n", decl.String())
}
result += "}"
}
return result
} | go | func (styleRule *StyleRule) String() string {
result := ""
result += styleRule.Selector
if len(styleRule.Declarations) == 0 {
result += ";"
} else {
result += " {\n"
for _, decl := range styleRule.Declarations {
result += fmt.Sprintf(" %s\n", decl.String())
}
result += "}"
}
return result
} | [
"func",
"(",
"styleRule",
"*",
"StyleRule",
")",
"String",
"(",
")",
"string",
"{",
"result",
":=",
"\"",
"\"",
"\n\n",
"result",
"+=",
"styleRule",
".",
"Selector",
"\n\n",
"if",
"len",
"(",
"styleRule",
".",
"Declarations",
")",
"==",
"0",
"{",
"resu... | // Returns the string representation of a style rule | [
"Returns",
"the",
"string",
"representation",
"of",
"a",
"style",
"rule"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/inliner/style_rule.go#L52-L70 |
93 | aymerick/douceur | css/declaration.go | StringWithImportant | func (decl *Declaration) StringWithImportant(option bool) string {
result := fmt.Sprintf("%s: %s", decl.Property, decl.Value)
if option && decl.Important {
result += " !important"
}
result += ";"
return result
} | go | func (decl *Declaration) StringWithImportant(option bool) string {
result := fmt.Sprintf("%s: %s", decl.Property, decl.Value)
if option && decl.Important {
result += " !important"
}
result += ";"
return result
} | [
"func",
"(",
"decl",
"*",
"Declaration",
")",
"StringWithImportant",
"(",
"option",
"bool",
")",
"string",
"{",
"result",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"decl",
".",
"Property",
",",
"decl",
".",
"Value",
")",
"\n\n",
"if",
"option"... | // StringWithImportant returns string representation with optional !important part | [
"StringWithImportant",
"returns",
"string",
"representation",
"with",
"optional",
"!important",
"part"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/css/declaration.go#L23-L33 |
94 | aymerick/douceur | css/declaration.go | Equal | func (decl *Declaration) Equal(other *Declaration) bool {
return (decl.Property == other.Property) && (decl.Value == other.Value) && (decl.Important == other.Important)
} | go | func (decl *Declaration) Equal(other *Declaration) bool {
return (decl.Property == other.Property) && (decl.Value == other.Value) && (decl.Important == other.Important)
} | [
"func",
"(",
"decl",
"*",
"Declaration",
")",
"Equal",
"(",
"other",
"*",
"Declaration",
")",
"bool",
"{",
"return",
"(",
"decl",
".",
"Property",
"==",
"other",
".",
"Property",
")",
"&&",
"(",
"decl",
".",
"Value",
"==",
"other",
".",
"Value",
")",... | // Equal returns true if both Declarations are equals | [
"Equal",
"returns",
"true",
"if",
"both",
"Declarations",
"are",
"equals"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/css/declaration.go#L36-L38 |
95 | aymerick/douceur | inliner/inliner.go | NewInliner | func NewInliner(html string) *Inliner {
return &Inliner{
html: html,
elements: make(map[string]*Element),
}
} | go | func NewInliner(html string) *Inliner {
return &Inliner{
html: html,
elements: make(map[string]*Element),
}
} | [
"func",
"NewInliner",
"(",
"html",
"string",
")",
"*",
"Inliner",
"{",
"return",
"&",
"Inliner",
"{",
"html",
":",
"html",
",",
"elements",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"Element",
")",
",",
"}",
"\n",
"}"
] | // NewInliner instanciates a new Inliner | [
"NewInliner",
"instanciates",
"a",
"new",
"Inliner"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/inliner/inliner.go#L48-L53 |
96 | aymerick/douceur | inliner/inliner.go | Inline | func Inline(html string) (string, error) {
result, err := NewInliner(html).Inline()
if err != nil {
return "", err
}
return result, nil
} | go | func Inline(html string) (string, error) {
result, err := NewInliner(html).Inline()
if err != nil {
return "", err
}
return result, nil
} | [
"func",
"Inline",
"(",
"html",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"result",
",",
"err",
":=",
"NewInliner",
"(",
"html",
")",
".",
"Inline",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",... | // Inline inlines css into html document | [
"Inline",
"inlines",
"css",
"into",
"html",
"document"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/inliner/inliner.go#L56-L63 |
97 | aymerick/douceur | inliner/inliner.go | Inline | func (inliner *Inliner) Inline() (string, error) {
// parse HTML document
if err := inliner.parseHTML(); err != nil {
return "", err
}
// parse stylesheets
if err := inliner.parseStylesheets(); err != nil {
return "", err
}
// collect elements and style rules
inliner.collectElementsAndRules()
// inline css
if err := inliner.inlineStyleRules(); err != nil {
return "", err
}
// insert raw stylesheet
inliner.insertRawStylesheet()
// generate HTML document
return inliner.genHTML()
} | go | func (inliner *Inliner) Inline() (string, error) {
// parse HTML document
if err := inliner.parseHTML(); err != nil {
return "", err
}
// parse stylesheets
if err := inliner.parseStylesheets(); err != nil {
return "", err
}
// collect elements and style rules
inliner.collectElementsAndRules()
// inline css
if err := inliner.inlineStyleRules(); err != nil {
return "", err
}
// insert raw stylesheet
inliner.insertRawStylesheet()
// generate HTML document
return inliner.genHTML()
} | [
"func",
"(",
"inliner",
"*",
"Inliner",
")",
"Inline",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"// parse HTML document",
"if",
"err",
":=",
"inliner",
".",
"parseHTML",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err"... | // Inline inlines CSS and returns HTML | [
"Inline",
"inlines",
"CSS",
"and",
"returns",
"HTML"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/inliner/inliner.go#L66-L90 |
98 | aymerick/douceur | inliner/inliner.go | parseHTML | func (inliner *Inliner) parseHTML() error {
doc, err := goquery.NewDocumentFromReader(strings.NewReader(inliner.html))
if err != nil {
return err
}
inliner.doc = doc
return nil
} | go | func (inliner *Inliner) parseHTML() error {
doc, err := goquery.NewDocumentFromReader(strings.NewReader(inliner.html))
if err != nil {
return err
}
inliner.doc = doc
return nil
} | [
"func",
"(",
"inliner",
"*",
"Inliner",
")",
"parseHTML",
"(",
")",
"error",
"{",
"doc",
",",
"err",
":=",
"goquery",
".",
"NewDocumentFromReader",
"(",
"strings",
".",
"NewReader",
"(",
"inliner",
".",
"html",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",... | // Parses raw html | [
"Parses",
"raw",
"html"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/inliner/inliner.go#L93-L102 |
99 | aymerick/douceur | inliner/inliner.go | parseStylesheets | func (inliner *Inliner) parseStylesheets() error {
var result error
inliner.doc.Find("style").EachWithBreak(func(i int, s *goquery.Selection) bool {
stylesheet, err := parser.Parse(s.Text())
if err != nil {
result = err
return false
}
inliner.stylesheets = append(inliner.stylesheets, stylesheet)
// removes parsed stylesheet
s.Remove()
return true
})
return result
} | go | func (inliner *Inliner) parseStylesheets() error {
var result error
inliner.doc.Find("style").EachWithBreak(func(i int, s *goquery.Selection) bool {
stylesheet, err := parser.Parse(s.Text())
if err != nil {
result = err
return false
}
inliner.stylesheets = append(inliner.stylesheets, stylesheet)
// removes parsed stylesheet
s.Remove()
return true
})
return result
} | [
"func",
"(",
"inliner",
"*",
"Inliner",
")",
"parseStylesheets",
"(",
")",
"error",
"{",
"var",
"result",
"error",
"\n\n",
"inliner",
".",
"doc",
".",
"Find",
"(",
"\"",
"\"",
")",
".",
"EachWithBreak",
"(",
"func",
"(",
"i",
"int",
",",
"s",
"*",
... | // Parses and removes stylesheets from HTML document | [
"Parses",
"and",
"removes",
"stylesheets",
"from",
"HTML",
"document"
] | f9e29746e1161076eae141dd235f5d98b546ec3e | https://github.com/aymerick/douceur/blob/f9e29746e1161076eae141dd235f5d98b546ec3e/inliner/inliner.go#L105-L124 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.