cloud_file 0.0.1

data/lib/cloud_file/address.rb

@@ -0,0 +1,43 @@
+puts 'loading address'
+
+module CloudFile
+  class Address
+    include FromHash
+    attr_accessor :user, :provider, :loc
+
+    def service
+      cls = ::CloudFile::Services.service_class(provider)
+      cls.for_user(user)
+    end
+
+    def open(&b)
+      service.open(loc,&b)
+    end
+
+    def files
+      service.files
+    end
+
+    class << self
+      def parse(str)
+        raise "bad #{str}" unless str =~ /^(.+):\/\/(.+)$/
+        service_class = ::CloudFile::Services.service_class($1)
+        loc = service_class.uri_parser.parse(str)
+        provider = loc.delete('provider')
+
+        make(:provider => provider, :user => Tokens.user, :loc => loc)
+      end
+      def make(ops)
+        if ops[:loc]
+          new(ops)
+        else
+          res = new
+          res.user = ops.delete(:user)
+          res.provider = ops.delete(:provider)
+          res.loc = ops
+          res
+        end
+      end
+    end
+  end
+end

data/lib/cloud_file/cloud_uri.rb

@@ -0,0 +1,10 @@
+%w(dsl).each do |f|
+  load File.expand_path(File.dirname(__FILE__)) + "/cloud_uri/#{f}.rb"
+end
+
+module CloudFile
+  class CloudUri
+    include FromHash
+
+  end
+end

data/lib/cloud_file/cloud_uri/dsl.rb

@@ -0,0 +1,80 @@
+module CloudFile
+  class CloudUri
+    class Dsl
+      include FromHash
+      attr_accessor :service_class, :format
+
+      def self.regex
+        /^(.+):\/\/([^\/]+)((?:\/[^\/]+)*)/
+      end
+
+      def matches(str)
+        raise "no matches" unless str =~ self.class.regex
+
+        res = [$1,$2]
+        if $3.present?
+          res += $3[1..-1].split("/")
+        end
+        res
+      end
+
+      def params
+        [':provider'] + format.split("/")
+      end
+
+      def result(str)
+        matches = matches(str)
+        res = {}
+        add = lambda do |k,i|
+          val = matches[i]
+          if val.kind_of?(Array)
+            raise "bad" if val.empty?
+            val = val.join("/")
+          else
+            raise "bad" unless val.present?
+          end
+          res[k] = val
+        end
+
+        params.each_with_index do |param,i|
+          if param =~ /^:/
+            k = param[1..-1]
+            add[k,i]
+          elsif param =~ /^*:/
+            k = param[2..-1]
+            add[k,(i..99)]
+          else
+            # do nothing
+          end
+        end
+
+        HashWithIndifferentAccess.new(res)
+      end
+      def parse(str)
+        result(str)
+      end
+
+      def run!
+        service_class.uri_parser = self
+      end
+    end
+  end
+end
+
+def process_route(route, pattern, keys, conditions, block = nil, values = [])
+  route = '/' if route.empty? and not settings.empty_path_info?
+  return unless match = pattern.match(route)
+  values += match.captures.to_a.map { |v| force_encoding URI.decode(v) if v }
+
+  if values.any?
+    original, @params = params, params.merge('splat' => [], 'captures' => values)
+    keys.zip(values) { |k,v| Array === @params[k] ? @params[k] << v : @params[k] = v if v }
+  end
+
+  catch(:pass) do
+    conditions.each { |c| throw :pass if c.bind(self).call == false }
+    block ? block[self, values] : yield(self, values)
+  end
+ensure
+  @params = original if original
+end

data/lib/cloud_file/convertors.rb

@@ -0,0 +1,76 @@
+module CloudFile
+  class Convertors
+    class << self
+      fattr(:instance) { new }
+      def method_missing(sym,*args,&b)
+        instance.send(sym,*args,&b)
+      end
+    end
+
+    include FromHash
+    fattr(:list) { [] }
+    def register(ops,&b)
+      #puts "ops #{ops.inspect}"
+      self.list = list.reject { |x| x[:from].to_s == ops.keys.first.to_s && x[:to].to_s == ops.values.first.to_s }
+      self.list << {:from => ops.keys.first.to_s, :to => ops.values.first.to_s, :block => b}
+    end
+    def convert_inner(from,to,str)
+      block = list.find { |x| x[:from].to_s == from.to_s && x[:to].to_s == to.to_s }
+      raise "no convertor" unless block
+      block[:block][str]
+    end
+    def convert(from,to,str)
+      path = find_path(from,to)
+      raise "no path from #{from} to #{to}" unless path
+      if path.empty?
+        convert_inner(from,to,str)
+      else
+        str = convert_inner(from,path.first,str)
+        convert(path.first,to,str)
+      end
+    end
+
+    def graph
+      require 'rgl/adjacency'
+      a = []
+      list.each do |c|
+        a << c[:from]
+        a << c[:to]
+      end
+      RGL::DirectedAdjacencyGraph[*a]
+    end
+
+    def find_path(source,target,prev=[])
+      raise "bad source: #{source} target: #{target}" if target.to_s == source.to_s
+      tos = list.select { |x| x[:from] == source.to_s }.map { |x| x[:to] }
+      puts "tos #{tos.inspect}"
+      if tos.any? { |x| x == target.to_s }
+        prev
+      elsif tos.empty?
+        nil
+      else
+        tos.each do |to|
+          p = prev + [to]
+          res = find_path(to,target,p)
+          return res if res
+        end
+        nil
+      end
+    end
+  end
+end
+
+CloudFile::Convertors.register :html => :text do |str|
+  #str.gsub(/<[^>]+>/,"")
+  require 'nokogiri'
+
+  doc = Nokogiri::HTML(str)
+  if doc.css("body").length > 0
+    doc.css("body").text
+  else
+    doc.text
+  end
+end
+
+
+

data/lib/cloud_file/copy.rb

@@ -0,0 +1,15 @@
+module CloudFile
+  class Copy
+    include FromHash
+    attr_accessor :source, :target, :format
+
+    def run!
+      CloudFile.open(source) do |s|
+        CloudFile.open(target) do |t|
+          #t << s.read_format(format || t.service.class.format)
+          t << s.read
+        end
+      end
+    end
+  end
+end

data/lib/cloud_file/file.rb

@@ -0,0 +1,28 @@
+class File
+  def self.crfate(file,val)
+    open(file,"w") do |f|
+      f << val
+    end
+  end
+end
+
+module CloudFile
+  class File
+    include FromHash
+    attr_accessor :loc, :service
+
+    def read
+      service.read(loc)
+    end
+    def write(val)
+      service.write(loc,val)
+    end
+    def <<(*args)
+      write(*args)
+    end
+
+    def read_format(format)
+      service.read_format(format,loc)
+    end
+  end
+end

data/lib/cloud_file/outer_service.rb

@@ -0,0 +1,22 @@
+module CloudFile
+  class OuterService
+    include FromHash
+    attr_accessor :service
+
+    def parse_loc(loc)
+      if loc.kind_of?(String)
+        loc = service.class.uri_parser.parse(loc)
+      end
+      loc
+    end
+
+    def read(loc)
+      raise 'foo'
+      service.read parse_loc(loc)
+    end
+
+    def write(loc,val)
+      service.write parse_loc(loc),val
+    end
+  end
+end

data/lib/cloud_file/providers/dropbox.rb

@@ -0,0 +1,25 @@
+::Dropbox::API::Config.app_key    = "wncno17ygixgpy2"
+::Dropbox::API::Config.app_secret = "om9yb57exzqb201"
+::Dropbox::API::Config.mode       = "dropbox"
+
+module CloudFile
+  
+  class Dropbox < Service
+    register :provider => "dropbox", :format => :text
+    uri_format "*:path"
+    fattr(:client) do
+      #puts "token #{access_token} secret #{access_secret}"
+      ::Dropbox::API::Client.new :token => access_token, :secret => access_secret
+    end
+    def read(loc)
+      #puts "dropbox read #{loc.inspect}"
+      url = client.find(loc[:path]).direct_url
+      #puts url
+      #puts "about to read #{loc[:path]}"
+      client.download(loc[:path])
+    end
+    def write(loc,content)
+      client.upload loc[:path],content
+    end
+  end
+end

data/lib/cloud_file/providers/evernote.rb

@@ -0,0 +1,78 @@
+module CloudFile
+  class Evernote < Service
+    register :provider => "evernote", :format => :evernote_html
+    uri_format ":notebook/:title"
+    
+    fattr(:client) do
+      EvernoteOAuth::Client.new(token: access_token)
+    end
+    fattr(:note_store) do
+      client.note_store
+    end
+
+    def get_notebook(book)
+      note_store.listNotebooks.find { |x| x.name == book }
+    end
+    def get_note_shell(book,title)
+      book = get_notebook(book)
+
+      filter = ::Evernote::EDAM::NoteStore::NoteFilter.new
+      filter.notebookGuid = book.guid
+      #filter.words = title
+      notes = note_store.findNotes(filter,0,10)
+
+      notes.notes.find { |x| x.title == title }
+    end
+    def get_note(book,title)
+      shell = get_note_shell(book,title)
+      unless shell
+        raise "no note found"
+      end
+
+      note_store.getNote(shell.guid, true, true, false, false)
+    end
+    def create_note(book,title,content)
+      note = ::Evernote::EDAM::Type::Note.new
+      note.title = title
+      #note.content = ""
+      note.content = '<!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd">
+    <en-note>' + content + '</en-note>'
+      note.notebookGuid = get_notebook(book).guid
+
+      note_store.createNote(note)
+    end
+    def update_note(book,title,content)
+      note = get_note(book,title)
+      unless content =~ /DOCTYPE/
+        content = '<!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd">
+        <en-note>' + content + '</en-note>'
+      end
+      note.content = content
+      note_store.updateNote(note)
+    end
+    def write_note(book,title,content)
+      if get_note_shell(book,title)
+        update_note(book,title,content)
+      else
+        create_note(book,title,content)
+      end
+    end
+
+
+    def read(loc)
+      res = get_note(loc[:notebook],loc[:title]).content
+      #raise "no match" unless res =~ /<en-note>(.*)<\/en-note>/
+      #$1
+    end
+    def write(loc,content)
+      write_note(loc[:notebook],loc[:title],content)
+    end
+
+    
+    register_converter :evernote_html => :html do |str|
+      raise "no match" unless str =~ /<en-note>(.*)<\/en-note>/
+      $1
+    end
+
+  end
+end

data/lib/cloud_file/providers/gdrive.rb

@@ -0,0 +1,39 @@
+module CloudFile
+  class Gdrive < Service
+    register :provider => "google_oauth2", :format => :gdoc
+    uri_format ":title"
+
+    fattr(:client) do
+      GoogleDrive.login_with_oauth(access_token)
+    end
+
+    def temp_file
+      "/users/mharris717/multi.txt"
+    end
+
+    def read(loc)
+      file = client.file_by_title(loc[:title])
+      file.download_to_file temp_file
+      ::File.read temp_file
+    end
+
+    def write(loc,val)
+      ::File.create temp_file,val
+      client.upload_from_file(temp_file, loc[:title], :convert => true)
+    end
+
+    def list
+      client.files.map do |f|
+        if f.title.downcase =~ /interview/
+          ::File.create "entry.xml",f.document_feed_entry.to_s 
+          raise 'foo'
+        end
+        {:title => f.title}
+      end
+    end
+
+    register_converter :gdoc => :html do |str|
+      str
+    end
+  end
+end

data/lib/cloud_file/providers/local.rb

@@ -0,0 +1,19 @@
+module CloudFile
+  class Local < Service
+    register :provider => "local"
+    uri_format ":file"
+    
+    def read(ops)
+      ::File.read ops[:file]
+    end
+    def write(ops,val)
+      ::File.create ops[:file],val
+    end
+
+    class << self
+      def for_user(user)
+        new
+      end
+    end
+  end
+end