@xriss/weerss 0.0.2

package/shows.js

@@ -0,0 +1,249 @@
+
+
+let shows={}
+export default shows
+
+
+import      hoard     from "./hoard.js"
+import      db        from "./db.js"
+import      jxml      from "./jxml.js"
+
+import { configure } from 'safe-stable-stringify'
+const stringify = configure({})
+
+import weerss from "./weerss.js"
+
+// cleanup a file name as best we can to be used in search
+shows.clean_name=function(name)
+{
+	return name.replace(/'|’/g,"").replace(/[^a-zA-Z0-9]/g," ").replace(/\s+/g," ").trim().toLowerCase()
+}
+
+
+shows.get=async function(url) // always slow
+{
+	return await db.get("shows",url)
+}
+
+shows.set=async function(show)
+{
+	await db.set("shows",show.url,show)
+}
+
+
+shows.fetch=async function(url,force)
+{
+	if(!force)
+	{
+		let ret = await shows.get(url)
+		if( ret && ret.data) { return ret.data }
+	}
+	
+	let data = await fetch(url).then(res => res.json())
+	if(data)
+	{
+		await shows.set({url:url,data:data})
+	}
+	return data
+}
+
+
+shows.prepare=function(show)
+{
+	return show
+}
+
+
+// lookup show on tvmaze
+shows.get_tvmaze=async function(show,force)
+{
+	try{ // on network errors, just return non tvmaze info
+
+		let show_year
+		let show_country
+		let show_name=show.name
+		let qurl="https://api.tvmaze.com/singlesearch/shows?q="+show_name.replaceAll(" ","+")
+		let tvmaze=await shows.fetch(qurl,force)
+
+		if(!tvmaze) // maybe try again
+		{
+			if( show_name.match(/\s\d\d\d\d$/i) ) // maybe a four digit year
+			{
+				show_year=show_name.substring(show_name.length-4)
+				show_name=show_name.substring(0,show_name.length-5)
+				qurl="https://api.tvmaze.com/singlesearch/shows?q="+show_name.replaceAll(" ","+")
+				tvmaze=await shows.fetch(qurl,force)
+				if(tvmaze)
+				{
+					show.year=show_year // remember the year we removed
+				}
+			}
+		}
+		
+		if(!tvmaze) // maybe try again
+		{
+			if( show_name.match(/\s\w\w$/i) ) // maybe a two letter country code
+			{
+				show_country=show_name.substring(show_name.length-2)
+				show_name=show_name.substring(0,show_name.length-3)
+				qurl="https://api.tvmaze.com/singlesearch/shows?q="+show_name.replaceAll(" ","+")
+				tvmaze=await shows.fetch(qurl,force)
+				if(tvmaze)
+				{
+					show.country=show_country // remember the country we removed
+				}
+			}
+		}
+		
+		if(tvmaze && tvmaze.name=="Too Many Requests") // ERROR
+		{
+			tvmaze=undefined
+		}
+
+		show.tvmaze=tvmaze
+		show.id=tvmaze && tvmaze.id
+
+	}catch(e){console.log(e)}
+
+	return show.tvmaze
+}
+
+// guess the show and series/episode or movie from an item
+shows.get_show=async function(filename)
+{	
+	let item_tags
+	let item_name
+	let item_season
+	let item_episode
+	
+	let name=filename
+	if(!name){return} // give up
+	
+	if(!item_name)
+	{
+		let aa=name.match(/(.*)S(\d\d+)E(\d\d+)(.*)/i)
+		if(aa) // found a season
+		{
+			item_name=shows.clean_name(aa[1])
+			item_season=Number(aa[2])
+			item_episode=Number(aa[3])
+			item_tags=shows.clean_name(aa[4]).split(" ")
+		}
+	}
+
+// try and match a date if we did not find an episode ?
+	if(!item_name)
+	{
+		let aa=name.match(/(.*)(\d\d\d\d)\D(\d\d)\D(\d\d)(.*)/i)
+		if(aa) // found a data
+		{
+			item_name=aa[1].replace(/[^a-zA-Z0-9]/g," ").replace(/\s+/g," ").trim().toLowerCase()
+			item_season=Number(aa[2]) // season is the year
+			item_episode=Number(aa[3]+aa[4]) // join month and day to make a 4 digit episode number
+			item_tags=aa[5].replace(/[^a-zA-Z0-9]/g," ").replace(/\s+/g," ").trim().toLowerCase().split(" ")
+		}
+	}
+	
+	if(!item_name){return} // give up
+
+	let show={
+		name:item_name,
+		tags:item_tags,
+		season:item_season,
+		episode:item_episode,
+	}
+	
+	await shows.get_tvmaze(show)
+
+	return show
+}
+
+// guess the show and series/episode or movie from an item
+shows.fill_show=async function(item)
+{	
+
+	item.show=await shows.get_show(item.torrent.file_name)	
+	
+	item.show=item.show||{fail:true}
+
+	return item
+}
+
+
+let check_flags=function(flags,rules)
+{
+	let good=false
+
+if(weerss.config.debug)
+{
+	console.log("checking rules",flags)
+}
+	
+	for( let rule of rules )
+	{
+		for( let s of rule )
+		{
+			if( "string" == typeof s ) // all these must be true
+			{
+				if( s.startsWith("!") )
+				{
+					s=s.substring(1)
+					if( flags[s] ) { break }
+				}
+				else
+				{
+					if( !flags[s] ) { break }
+				}
+			}
+			else
+			if( "boolean" == typeof s ) // to set this flag
+			{
+if(weerss.config.debug)
+{
+	console.log("rule matched",rule)
+}
+				good=s
+				break
+			}
+		}
+		
+	}
+if(weerss.config.debug)
+{
+	console.log("result",good,"\n")
+}
+	return good
+}
+
+// is this show good?
+shows.good_show=function(show,rules)
+{
+	if( !rules ) { return true }
+	
+	let tvmaze=show.tvmaze||{}
+	
+	let flags={}
+	if( tvmaze.language ) { flags[ tvmaze.language.trim().toLowerCase() ]=true }
+	if( tvmaze.type     ) { flags[ tvmaze.type.trim().toLowerCase()     ]=true }
+	if( tvmaze.genres )
+	for( let genre of tvmaze.genres || [] )
+	{
+		flags[ genre.trim().toLowerCase() ]=true
+	}
+	
+	return check_flags(flags,rules)
+}
+
+// is this episode good?
+shows.good_episode=function(show,rules)
+{
+	if( !rules ) { return true }
+
+	let flags={}
+	for( let tag of show.tags || [] )
+	{
+		flags[ tag.trim().toLowerCase() ]=true
+	}
+
+	return check_flags(flags,rules)
+}

package/torrents.js

@@ -0,0 +1,116 @@
+
+
+let torrents={}
+export default torrents
+
+
+import      db        from "./db.js"
+
+import { remote } from 'parse-torrent'
+
+
+
+
+torrents.get=async function(url) // always slow
+{
+	return await db.get("torrents",url)
+}
+
+torrents.set=async function(torrent)
+{
+	await db.set("torrents",torrent.url,torrent)
+}
+
+
+torrents.fetch=async function(url)
+{
+	let ret = await torrents.get(url)
+	if( ret && ret.data) { return ret.data }
+	
+	let torrent_parse=function(torrent) {
+		return new Promise(function(resolve, reject) {
+			remote(torrent, { timeout: 60 * 1000 }, function(err, parsedTorrent){
+				if (err) { reject(err) }
+				resolve(parsedTorrent)
+			})
+		})
+	}
+	let data=await torrent_parse(url) // should work with magnets
+
+	if(data)
+	{
+		await torrents.set({url:url,data:data})
+	}
+	return data
+}
+
+
+torrents.prepare=function(torrent)
+{
+	return torrent
+}
+
+// fill in the torrent part of an item
+torrents.fill_torrent=async function(item)
+{	
+	let torrent_name
+	
+	if(!torrent_name){
+		try{
+			torrent_name=item.rss["/enclosure"][0]["@url"]
+		}catch(e){}
+	}
+
+	if(!torrent_name){
+		try{
+			torrent_name=item.rss["/link"]			
+		}catch(e){}
+	}
+
+// hax archive.org to torrents
+	if(torrent_name)
+	{
+		let aa=torrent_name.split("https://archive.org/download/")
+		if(aa[1])
+		{
+			let name=aa[1].split("/")[0]
+			if(name)
+			{
+				torrent_name="https://archive.org/download/"+name+"/"+name+"_archive.torrent"
+			}
+		}
+	}
+
+
+
+	try{
+
+		item.torrent={fail:true}
+		let torrent=await torrents.fetch(torrent_name) // should work with magnets
+		
+		if( torrent ) // did we get something
+		{
+			item.torrent={fail:true}
+			
+			for(let file of torrent.files)
+			{
+				let pct=Math.floor(100*file.length/torrent.length)
+				if(pct>75) // torrent must be mostly this one file
+				{
+					item.torrent={
+						torrent_name:torrent_name,
+						torrent_length:torrent.length,
+						file_name:file.name,
+						file_length:file.length
+					}
+					break
+				}
+			}
+		}
+
+	}catch(e){console.log(e)}
+
+
+	return item
+}
+

package/webpack.config.cjs

@@ -0,0 +1,61 @@
+const path = require('path');
+
+const webpack = require('webpack');
+
+
+let dd=new Date()
+let da=new Date(dd.getFullYear(), 0, 0)
+let db=new Date(dd.getFullYear()+1, 0, 0)
+let dd_yy=(dd.getFullYear()-2000)
+let dd_dd=Math.floor( 100000 * (dd-da) / (db-da) )
+let dd_version=dd_yy+"."+( ("0000"+dd_dd).slice(-5) )
+
+console.log("VERSION == "+dd_version)
+
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.(txt|md|html|css|csv)$/i,
+        use: 'raw-loader',
+      },
+    ],
+  },
+  plugins: [
+	new webpack.DefinePlugin({
+		__THIS_IS_WEBPACK__:true,
+		__VERSION__: JSON.stringify(dd_version)
+	}),
+    new webpack.ProvidePlugin({
+      process: 'process/browser',
+    }),
+	new webpack.ProvidePlugin({
+		Buffer: ['buffer', 'Buffer'],
+	}),
+  ],
+  entry: './weerss.js',
+  resolve: {
+    fallback : {
+		fs: false,
+		url: false,
+		path: require.resolve("path-browserify"),
+		"stream": require.resolve("stream-browserify"),
+		"buffer": require.resolve("buffer/"),
+    },
+  },
+  performance: {
+    hints: false,
+    maxEntrypointSize: 555555,
+    maxAssetSize: 555555,
+  },
+  output: {
+    path: path.resolve(__dirname, '../docs/js/'),
+    filename: 'weerss.js',
+    globalObject: 'this',
+    library: {
+      name: 'weerss',
+      type: 'umd',
+    },
+  },
+};
+