rmega 0.1.7 → 0.2.0

data/lib/rmega/utils.rb

@@ -2,203 +2,43 @@ module Rmega
   module Utils
     extend self
 
-    def str_to_a32(string)
-      size = (string.bytesize + 3) >> 2
-      string = string.ljust (string.bytesize + 3), "\x00"
-      string.unpack "l>#{size}"
-    end
-
-    def a32_to_str(a32, len = nil)
-      if len
-        b = []
-        len.times do |i|
-          # TODO: should be ((a32[i>>2] >>> (24-(i & 3)*8)) & 255)
-          b << (((a32[i>>2] || 0) >> (24-(i & 3)*8)) & 255)
-        end
-        b.pack 'C*'
-      else
-        a32.pack 'l>*'
-      end
-    end
-
-    def b64a
-      @b64a ||= ('A'..'Z').to_a + ('a'..'z').to_a + ('0'..'9').to_a + ["-", "_", "="]
-    end
-
-    def a32_to_base64(a32)
-      base64urlencode a32_to_str(a32)
-    end
-
-    def base64_to_a32(base64)
-      str_to_a32 base64urldecode(base64)
-    end
-
     def base64urlencode(string)
-      i = 0
-      tmp_arr = []
-
-      while i < string.size + 1
-        o1 = string[i].ord rescue 0
-        i += 1
-        o2 = string[i].ord rescue 0
-        i += 1
-        o3 = string[i].ord rescue 0
-        i += 1
-
-        bits = o1 << 16 | o2 << 8 | o3
-
-        h1 = bits >> 18 & 0x3f
-        h2 = bits >> 12 & 0x3f
-        h3 = bits >> 6 & 0x3f
-        h4 = bits & 0x3f
-
-        tmp_arr.push b64a[h1] + b64a[h2] + b64a[h3] + b64a[h4]
-      end
-
-      enc = tmp_arr.join ''
       r = string.size % 3
-      (r != 0) ? enc[0..r - 4] : enc
+      encoded = Base64.urlsafe_encode64(string)
+      return (r != 0) ? encoded[0..r - 4] : encoded
     end
 
     def base64urldecode(data)
-      data += '=='[((2-data.length*3)&3)..-1]
-
-      i = 0
-      ac = 0
-      dec = ""
-      tmp_arr = []
-
-      return data unless data
-
-      while i < data.size
-        h1 = b64a.index(data[i]) || -1
-        i += 1
-        h2 = b64a.index(data[i]) || -1
-        i += 1
-        h3 = b64a.index(data[i]) || -1
-        i += 1
-        h4 = b64a.index(data[i]) || -1
-        i += 1
-
-        bits = (h1 << 18) | (h2 << 12) | (h3 << 6) | h4
-
-        o1 = bits >> 16 & 0xff
-        o2 = bits >> 8 & 0xff
-        o3 = bits & 0xff
-
-        if h3 == 64
-          tmp_arr[ac] = o1.chr
-        elsif h4 == 64
-          tmp_arr[ac] = o1.chr + o2.chr
-        else
-          tmp_arr[ac] = o1.chr + o2.chr + o3.chr
-        end
-
-        ac += 1
-      end
-
-      tmp_arr.join ''
+      fix_for_decoding = '=='[((2-data.length*3)&3)..-1]
+      return Base64.urlsafe_decode64("#{data}#{fix_for_decoding}")
     end
 
-    def mpi2b(s)
-      bn = 1
-      r = [0]
-      rn = 0
-      sb = 256
-      sn = s.size
-      bm = 268435455
-      c = nil
-
-      return 0 if sn < 2
-
-      len = (sn - 2) * 8
-      bits = s[0].ord * 256 + s[1].ord
-
-      return 0 if bits > len or bits < len - 8
-
-      len.times do |n|
-        sb = sb << 1
-
-        if sb > 255
-          sb = 1
-          c = s[sn -= 1].ord
-        end
-
-        if bn > bm
-          bn = 1
-          r[rn += 1] = 0
-        end
-
-        if (c & sb) and (c & sb != 0)
-          r[rn] = r[rn] ? (r[rn] | bn) : bn
-        end
-
-        bn = bn << 1
-      end
-      r
+    def hexstr_to_bstr(h)
+      bstr = ''
+      (0..h.length-1).step(2) {|n| bstr << h[n,2].to_i(16).chr }
+      bstr
     end
 
-    def b2s(b)
-      bs = 28
-      bm = 268435455
-      bn = 1; bc = 0; r = [0]; rb = 1; rn = 0
-      bits = b.length * bs
-      rr = ''
-
-      bits.times do |n|
-        if (b[bc] & bn) and (b[bc] & bn) != 0
-          r[rn] = r[rn] ? (r[rn] | rb) : rb
-        end
-
-        rb = rb << 1
-
-        if rb > 255
-          rb = 1
-          r[rn += 1] = 0
-        end
-
-        bn = bn << 1
-
-        if bn > bm
-          bn = 1
-          bc += 1
-        end
-      end
-
-      while rn >= 0 && r[rn] == 0
-        rn -= 1
-      end
-
-      (rn + 1).times do |n|
-        rr = r[n].chr + rr
-      end
-
-      rr
+    def string_to_bignum(string)
+      string.bytes.inject { |a, b| (a << 8) + b }
     end
 
-    def chunks(size)
-      list = {}
-      p = 0
-      pp = 0
-      i = 1
+    def base64_mpi_to_bn(s)
+      data = ::Rmega::Utils.base64urldecode(s)
+      len = ((data[0].ord * 256 + data[1].ord + 7) / 8) + 2
+      data[2,len+2].unpack('H*').first.to_i(16)
+    end
 
-      while i <= 8 and p < size - (i * 0x20000)
-        list[p] = i * 0x20000
-        pp = p
-        p += list[p]
-        i += 1
-      end
+    def compact_to_8_bytes(string)
+      raise("Invalid data length") if string.size != 16
 
-      while p < size
-        list[p] = 0x100000
-        pp = p
-        p += list[p]
-      end
+      bytes = string.bytes.to_a
 
-      if size - pp > 0
-        list[pp] = size - pp
-      end
-      list
+      return 8.times.inject([]) do |ary, i|
+        n = i < 4 ? 0 : 4
+        ary[i] = bytes[i+n] ^ bytes[i+n+4]
+        ary
+      end.map(&:chr).join
     end
   end
 end

data/lib/rmega/version.rb

@@ -1,3 +1,4 @@
 module Rmega
-  VERSION = "0.1.7"
+  VERSION = "0.2.0"
+  HOMEPAGE = "https://github.com/topac/rmega"
 end

data/rmega.gemspec

@@ -2,11 +2,11 @@
 require File.expand_path('../lib/rmega/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Daniele Molteni"]
+  gem.authors       = ["topac"]
   gem.email         = ["dani.m.mobile@gmail.com"]
   gem.description   = %q{mega.co.nz ruby api}
   gem.summary       = %q{mega.co.nz ruby api}
-  gem.homepage      = "https://github.com/topac/rmega"
+  gem.homepage      = Rmega::HOMEPAGE
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
@@ -21,7 +21,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency "rspec"
   gem.add_development_dependency "rake"
 
-  gem.add_dependency "httpclient"
-  gem.add_dependency 'activesupport'
-  gem.add_dependency "execjs"
+  gem.add_dependency "activesupport"
 end

data/spec/integration/file_download_spec.rb

@@ -1,45 +1,27 @@
 require 'integration_spec_helper'
-require 'fileutils'
 
 describe 'File download' do
 
-  if account_file_exists?
+  context 'given a public mega url (a small file)' do
 
-    let(:storage) { login }
+    let(:url) { 'https://mega.co.nz/#!MAkg2Iab!bc9Y2U6d93IlRRKVYpcC9hLZjS4G278OPdH6nTFPDNQ' }
 
-    context 'given a public mega url (a small file)' do
-
-      # A file called testfile.txt containting the string "helloworld!"
-      let(:url) { 'https://mega.co.nz/#!MAkg2Iab!bc9Y2U6d93IlRRKVYpcC9hLZjS4G278OPdH6nTFPDNQ' }
-
-      it 'downloads the related file' do
-        storage.download(url, temp_folder)
-        related_file = File.join(temp_folder, 'testfile.txt')
-        expect(File.read(related_file)).to eq "helloworld!\n"
-      end
+    it 'downloads the related file' do
+      Rmega.download(url, temp_folder)
+      related_file = File.join(temp_folder, 'testfile.txt')
+      expect(File.read(related_file)).to eq "helloworld!\n"
     end
+  end
 
-    context 'given a public mega url (a big file)' do
-
-      # A file called testfile_big_15mb.txt containting the word "topac" repeated 3145728 times (~ 15mb)
-      let(:url) { 'https://mega.co.nz/#!NYVkDaLD!BKyN5SRpOaEtGnTcwiAqcxmJc7p-k0IPWKAW-471KRE' }
-
-      it 'downloads the related file' do
-        storage.download(url, temp_folder)
-        related_file = File.join(temp_folder, 'testfile_big_15mb.txt')
-
-        expect(File.size(related_file)).to eql 15_728_640
+  context 'given a public mega url (a big file)' do
 
-        count = 0
-        File.open(related_file, 'rb') do |f|
-          while (word = f.read(3840))
-            break if word != "topac"*768
-            count += 768
-          end
-        end
+    let(:url) { 'https://mega.co.nz/#!NYVkDaLD!BKyN5SRpOaEtGnTcwiAqcxmJc7p-k0IPWKAW-471KRE' }
 
-        expect(count).to eql(15_728_640 / 5)
-      end
+    it 'downloads the related file' do
+      Rmega.download(url, temp_folder)
+      related_file = File.join(temp_folder, 'testfile_big_15mb.txt')
+      md5 = Digest::MD5.file(related_file).hexdigest
+      expect(md5).to eq("0451dc82ac003dbef703342e40a1b8f6")
     end
   end
 end

data/spec/integration/file_integrity_spec.rb

@@ -0,0 +1,41 @@
+require 'integration_spec_helper'
+
+describe 'File integrity over upload/download operations' do
+
+  if account_file_exists?
+
+    before(:all) do
+      @storage = login
+    end
+
+    let(:name) { "test_file" }
+
+    let(:path) { File.join(temp_folder, name)}
+
+    [12, 1_024_000].each do |size|
+
+      context "when a file (#{size} bytes) is uploaded and then downloaded" do
+
+        let(:content) { OpenSSL::Random.random_bytes(size) }
+
+        let(:content_hash) { Digest::MD5.hexdigest(content) }
+
+        before do
+          File.open(path, 'wb') { |f| f.write(content) }
+          file = @storage.root.upload(path)
+          @file = @storage.nodes.find { |n| n.handle == file.handle }
+          expect(@file.name).to eq(name)
+          @file.download(path+".downloaded")
+        end
+
+        it 'it does not get corrupted' do
+          expect(Digest::MD5.file(path+".downloaded").hexdigest).to eq(content_hash)
+        end
+
+        after do
+          @file.delete if @file
+        end
+      end
+    end
+  end
+end

data/spec/integration/file_upload_spec.rb

@@ -1,5 +1,4 @@
 require 'integration_spec_helper'
-require 'fileutils'
 
 describe 'File upload' do
 
@@ -7,72 +6,27 @@ describe 'File upload' do
 
     before(:all) { @storage = login }
 
-    context 'upload a small file to the root folder' do
+    let(:name) { "test_file" }
 
-      before(:all) do
-        @name = "i_like_trains_#{rand(1E20)}"
-        @content = @name
-      end
-
-      def find_file
-        @storage.root.files.find { |f| f.name == @name }
-      end
-
-      let(:path) { File.join(temp_folder, @name) }
-
-      before do
-        File.open(path, 'wb') { |f| f.write(@content) }
-        @storage.root.upload(path)
-      end
-
-      it 'finds the uploaded file' do
-        file = find_file
-        file.delete
-        expect(file).not_to be_nil
-      end
+    let(:path) { File.join(temp_folder, name)}
 
-      context 'download the same file' do
-
-        let(:download_path) { "#{path}.downloaded" }
+    [12, 1_024_000].each do |size|
+      context "when a file (#{size} bytes) is uploaded" do
 
         before do
-          file = find_file
-          file.download(download_path)
-          file.delete
+          File.open(path, 'wb') { |f| f.write(OpenSSL::Random.random_bytes(size)) }
+          @file = @storage.root.upload(path)
         end
 
-        it 'has the expected content' do
-          expect(File.read(download_path)).to eql @content
+        it 'it can be found as a file node' do
+          found_node = @storage.root.files.find { |f| f.handle == @file.handle }
+          expect(found_node).not_to be_nil
         end
-      end
-    end
-
-    context 'upload a big file to a specific folder' do
-
-      before(:all) do
-        @name = "mine_turtles_#{rand(1E20)}"
-        @path = File.join(temp_folder, @name)
-        @buffer = "rofl" * 1024
 
-        File.open(@path, 'wb') do |f|
-          512.times { f.write(@buffer) }
+        after do
+          @file.delete if @file
         end
-
-        @folder = @storage.root.create_folder(@name)
-        @folder.upload(@path)
       end
-
-      it 'finds the uploaded file and verify its content' do
-        file = @folder.files.find { |f| f.name == @name }
-        download_path = "#{@path}.downloaded"
-        file.download(download_path)
-
-        File.open(download_path, 'rb') do |f|
-          512.times { expect(f.read(@buffer.size)).to eq(@buffer) }
-        end
-      end
-
-      after { @folder.delete if @folder }
     end
   end
 end