evertils 0.0.1

data/lib/helpers/evernote-enml.rb

@@ -0,0 +1,33 @@
+module Granify
+  module Helper
+    class EvernoteENML
+      attr_reader :element, :embeddable_element
+
+      def initialize(file = nil)
+        @file = file
+        @element = enml_element
+
+        if !@element.nil?
+          @embeddable_element = "<hr/>Attachment with hash #{@element.data.bodyHash}<br /><en-media type=\"#{@element.mime}\" hash=\"#{@element.data.bodyHash}\" /><br /><br />"
+        end
+      end
+
+      private
+        def enml_element
+          if @file
+            read_file = File.open(@file, 'rb') { |io| io.read }
+
+            el = ::Evernote::EDAM::Type::Resource.new()
+            el.mime = MIME::Types.type_for(@file)[0].content_type
+            el.data = ::Evernote::EDAM::Type::Data.new()
+            el.data.size = read_file.size
+            el.data.bodyHash = Digest::MD5.hexdigest(read_file)
+            el.data.body = read_file
+            el.attributes = ::Evernote::EDAM::Type::ResourceAttributes.new()
+            el.attributes.fileName = @file # temporary for now, the actual file name
+            el
+          end
+        end
+    end
+  end
+end

data/lib/helpers/evernote-markdown.rb

@@ -0,0 +1,210 @@
+require 'rexml/document'
+require 'benchmark'
+include REXML
+include Benchmark
+
+# reverse markdown for ruby
+# author: JO
+# e-mail: xijo@gmx.de
+# date: 14.7.2009
+# version: 0.1
+# license: GPL
+# edited by: Daniel Spencer
+# https://github.com/indspenceable/en-cli/blob/master/lib/en/markdown_parser.rb
+
+# TODO
+# - ol numbering is buggy, in fact doesn't matter for markdown code
+
+module Granify
+  module Helper
+    class EvernoteMD
+      # set basic variables:
+      # - @li_counter: numbering list item (li) tags in an ordered list (ol)
+      # - @links:      hold the links for adding them to the bottom of the @output
+      #                this means 'reference style', please take a look at http://daringfireball.net/projects/markdown/syntax#link
+      # - @outout:     fancy markdown code in here!
+      # - @indent:     control indention level for nested lists
+      # - @errors:     appearing errors, like unknown tags, go into this array
+      def initialize()
+        @li_counter = 0
+        @links = []
+        @output = ""
+        @indent = 0
+        @errors = []
+      end
+      
+      # Invokes the HTML parsing by using a string. Returns the markdown code in @output.
+      # To garantuee well-formed xml for REXML a <root> element will be added, but has no effect.
+      # After parsing all elements, the 'reference style'-links will be inserted.
+      def parse_string(string)
+        doc = Document.new("<root>\n"+string+"\n</root>")
+        root = doc.root
+        root.elements.each do |element|
+          parse_element(element, :root)
+        end
+        insert_links()
+        @output
+      end
+      
+      # Parsing an element and its children (recursive) and writing its markdown code to @output
+      # 1. do indent for nested list items
+      # 2. add the markdown opening tag for this element
+      # 3a. if element only contains text, handle it like a text node
+      # 3b. if element is a container handle its children, which may be text- or element nodes
+      # 4. finally add the markdown ending tag for this element
+      def parse_element(element, parent)
+        name = element.name.to_sym
+        # 1.
+        @output << indent() if name.eql?(:li)
+        # 2.
+        @output << opening(element, parent)
+        
+        # 3a.
+        if (element.has_text? and element.children.size < 2)
+          @output << text_node(element, parent)
+        end
+        
+        # 3b.
+        if element.has_elements?
+          element.children.each do |child|
+            # increase indent if nested list
+            @indent += 1 if element.name=~/(ul|ol)/ and parent.eql?(:li)
+            
+            if child.node_type.eql?(:element)
+              parse_element(child, element.name.to_sym)
+            else
+              if parent.eql?(:blockquote)
+                @output << child.to_s.gsub("\n ", "\n>")
+              else
+                @output << child.to_s
+              end
+            end
+            
+            # decrease indent if end of nested list
+            @indent -= 1 if element.name=~/(ul|ol)/ and parent.eql?(:li)
+          end
+        end
+        
+        # 4.
+        @output << ending(element, parent)
+      end
+
+      # Returns opening markdown tag for the element. Its parent matters sometimes!
+      def opening(type, parent)
+        case type.name.to_sym
+          when :h1
+            "# "
+          when :li || :"en-todo"
+            parent.eql?(:ul) ? " - " : " "+(@li_counter+=1).to_s+". "
+          when :ol
+            @li_counter = 0
+            ""
+          when :ul
+            ""
+          when :h2
+            "## "
+          when :em
+            "*"
+          when :strong
+            "**"
+          when :blockquote
+            # remove leading newline
+            type.children.first.value = ""
+            "> "
+          when :code
+            parent.eql?(:pre) ? "    " : "`"
+          when :a
+            "["
+          when :img
+            "!["
+          when :hr
+            "----------\n\n"
+          else
+            @errors << "unknown start tag: "+type.name.to_s
+            ""
+        end
+      end
+      
+      # Returns the closing markdown tag, like opening()
+      def ending(type, parent)
+        case type.name.to_sym
+          when :h1
+            " #\n\n"
+          when :h2
+            " ##\n\n"
+          when :p
+            parent.eql?(:root) ? "\n\n" : "\n"
+          when :ol
+            parent.eql?(:li) ? "" : "\n"
+          when :ul
+            parent.eql?(:li) ? "" : "\n"
+          when :em
+            "*"
+          when :strong
+            "**"
+          when :li
+            ""
+          when :blockquote
+            ""
+          when :code
+            parent.eql?(:pre) ? "" : "`"
+          when :a
+            @links << type.attribute('href').to_s
+            "][" + @links.size.to_s + "] "
+          when :img
+            @links << type.attribute('src').to_s
+            "" + type.attribute('alt').to_s + "][" + @links.size.to_s + "] "
+            "#{type.attribute('alt')}][#{@links.size}] "
+          else
+            @errors << "  unknown end tag: "+type.name.to_s
+            ""
+        end
+      end
+      
+      # Perform indent: two space, @indent times - quite simple! :)
+      def indent
+        str = ""
+        @indent.times do
+          str << "  "
+        end
+        str
+      end
+      
+      # Return the content of element, which should be just text.
+      # If its a code block to indent of 4 spaces.
+      # For block quotation add a leading '>'
+      def text_node(element, parent)
+        if element.name.to_sym.eql?(:code) and parent.eql?(:pre)
+          element.text.gsub("\n","\n    ") << "\n"
+        elsif parent.eql?(:blockquote)
+          element.text.gsub!("\n ","\n>")
+        else
+          element.text
+        end
+      end
+      
+      # Insert the mentioned reference style links.
+      def insert_links
+        @output << "\n"
+        @links.each_index do |index|
+          @output << "  [#{index+1}]: #{@links[index]}\n"
+        end
+      end
+      
+      # Print out all errors, that occured and have been written to @errors.
+      def print_errors
+        @errors.each do |error|
+          puts error
+        end
+      end
+      
+      # Perform a benchmark on a given string n-times.
+      def speed_benchmark(string, n)
+        initialize()
+        bm(15) do |test|
+          test.report("reverse markdown:")    { n.times do; parse_string(string); initialize(); end; }
+        end
+      end
+    end
+  end
+end

data/lib/helpers/evernote.rb

@@ -0,0 +1,260 @@
+module Granify
+  module Helper
+    class Evernote
+      @@developer_token = ENV["EVERTILS_TOKEN"]
+
+      def initialize
+        authenticate
+      end
+
+      def authenticate
+        if @@developer_token.nil?
+          Notify.error("Evernote developer token is not configured properly!\n$EVERTILS_TOKEN == nil")
+        end
+
+        @evernoteHost = "www.evernote.com"
+        userStoreUrl = "https://#{@evernoteHost}/edam/user"
+
+        userStoreTransport = Thrift::HTTPClientTransport.new(userStoreUrl)
+        userStoreProtocol = Thrift::BinaryProtocol.new(userStoreTransport)
+        @@user = ::Evernote::EDAM::UserStore::UserStore::Client.new(userStoreProtocol)
+        @@shardId = user.shardId
+
+        versionOK = @@user.checkVersion("evernote-data",
+                   ::Evernote::EDAM::UserStore::EDAM_VERSION_MAJOR,
+                   ::Evernote::EDAM::UserStore::EDAM_VERSION_MINOR)
+
+        @version = "#{::Evernote::EDAM::UserStore::EDAM_VERSION_MAJOR}.#{::Evernote::EDAM::UserStore::EDAM_VERSION_MINOR}"
+
+        if !versionOK
+          Notify.error("Evernote API requires an update.  Latest version is #{@version}")
+        end
+
+        noteStoreUrl = @@user.getNoteStoreUrl(@@developer_token)
+
+        noteStoreTransport = Thrift::HTTPClientTransport.new(noteStoreUrl)
+        noteStoreProtocol = Thrift::BinaryProtocol.new(noteStoreTransport)
+        @@store = ::Evernote::EDAM::NoteStore::NoteStore::Client.new(noteStoreProtocol)
+      end
+
+      def info
+        {
+          :user => "#{user.name} (#{user.username}) - ID##{user.id}",
+          :shard => user.shardId,
+          :api_version => @version,
+        }
+      end
+
+      def notebooks
+        @@store.listNotebooks(@@developer_token)
+      end
+
+      def tags
+        @@store.listTags(@@developer_token)
+      end
+
+      def user
+        @@user.getUser(@@developer_token)
+      end
+
+      def notebook_by_name(name = $request.command)
+        output = {}
+        notebooks.each do |notebook|
+          if notebook.name == name.to_s.capitalize
+            output = notebook
+          end
+        end
+        
+        output
+      end
+
+      def notes_by_notebook(name)
+        output = {}
+        notebooks.each do |notebook|
+          if notebook.name.to_s == name.capitalize.to_s
+            filter = ::Evernote::EDAM::NoteStore::NoteFilter.new
+            filter.notebookGuid = notebook.guid
+
+            result = ::Evernote::EDAM::NoteStore::NotesMetadataResultSpec.new
+            result.includeTitle = true
+            result.includeUpdated = true
+            result.includeTagGuids = true
+
+            #output = @@store.findNotesMetadata(@@developer_token, filter, 0, 400, result)
+            notes(nil, notebook.guid).notes.each do |note|
+              output[note.guid] = @@store.getNoteContent(@@developer_token, note.guid)
+            end
+          end
+        end
+
+        output
+      end
+
+      def notebooks_by_stack(stack)
+        output = {}
+        notebooks.each do |notebook|
+          if notebook.stack == stack
+            #output[notebook.name] = []
+
+            filter = ::Evernote::EDAM::NoteStore::NoteFilter.new
+            filter.notebookGuid = notebook.guid
+
+            result = ::Evernote::EDAM::NoteStore::NotesMetadataResultSpec.new
+            result.includeTitle = true
+            result.includeUpdated = true
+            result.includeTagGuids = true
+
+            notes = @@store.findNotesMetadata(@@developer_token, filter, 0, 400, result)
+            output[notebook.name] = notes
+          end
+        end
+        
+        output
+      end
+
+      def note(title_filter = nil, notebook_filter = nil)
+        filter = ::Evernote::EDAM::NoteStore::NoteFilter.new
+        filter.words = "intitle:#{title_filter}" if title_filter
+        filter.notebookGuid = notebook_filter if notebook_filter
+
+        @@store.findNotes(@@developer_token, filter, nil, 1)
+      end
+
+      def notes(title_filter = nil, notebook_filter = nil)
+        filter = ::Evernote::EDAM::NoteStore::NoteFilter.new
+        filter.words = "intitle:#{title_filter}" if title_filter
+        filter.notebookGuid = notebook_filter if notebook_filter
+
+        @@store.findNotes(@@developer_token, filter, nil, 300)
+      end
+
+      def note_exists
+        note = note(date_templates[$request.command])
+        note.totalNotes > 0
+      end
+
+      def create_note(title = date_templates[$request.command], body = template_contents, p_notebook_name = nil, file = nil, share_note = false)
+        if $request.command == :weekly && !Date.today.monday?
+          Notify.error("Sorry, you can only create new weekly logs on Mondays")
+        end
+
+        # Create note object
+        our_note = ::Evernote::EDAM::Type::Note.new
+        our_note.resources = []
+        our_note.tagNames = []
+
+        # only join when required
+        if body.is_a? Array
+          body = body.join
+        end
+
+        # a file was requested, lets prepare it for storage
+        if !file.nil?
+          media_resource = EvernoteENML.new(file)
+          body.concat(media_resource.embeddable_element)
+          our_note.resources << media_resource.element
+        end
+
+        n_body = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+        n_body += "<!DOCTYPE en-note SYSTEM \"http://xml.evernote.com/pub/enml2.dtd\">"
+        n_body += "<en-note>#{body}</en-note>"
+       
+        # setup note properties
+        our_note.title = title
+        our_note.content = n_body
+
+        # properly tag logs
+        case $request.command
+        when :weekly
+          our_note.tagNames << "week-#{Time.now.strftime('%V').to_i}"
+        when :monthly
+          our_note.tagNames << "month-#{Time.now.strftime('%-m').to_i}"
+        end
+
+        if p_notebook_name.nil?
+          parent_notebook = notebook_by_name
+        else
+          parent_notebook = notebook_by_name(p_notebook_name)
+        end
+        
+        ## parent_notebook is optional; if omitted, default notebook is used
+        if parent_notebook.is_a? ::Evernote::EDAM::Type::Notebook
+          our_note.notebookGuid = parent_notebook.guid
+        end
+
+        ## Attempt to create note in Evernote account
+        begin
+          output = {}
+          output[:note] = @@store.createNote(@@developer_token, our_note)
+          
+          if share_note
+            shareKey = @@store.shareNote(@@developer_token, output[:note].guid)
+            output[:share_url] = "https://#{@evernoteHost}/shard/#{@@shardId}/sh/#{output[:note].guid}/#{shareKey}"
+          end
+        rescue ::Evernote::EDAM::Error::EDAMUserException => edue
+          ## Something was wrong with the note data
+          ## See EDAMErrorCode enumeration for error code explanation
+          ## http://dev.evernote.com/documentation/reference/Errors.html#Enum_EDAMErrorCode
+          Notify.error "EDAMUserException: #{edue}"
+        rescue ::Evernote::EDAM::Error::EDAMNotFoundException => ednfe
+          ## Parent Notebook GUID doesn't correspond to an actual notebook
+          Notify.error "EDAMNotFoundException: Invalid parent notebook GUID"
+        end
+
+        # A parent notebook object exists, otherwise it was saved to the default
+        # notebook
+        if parent_notebook.is_a? ::Evernote::EDAM::Type::Notebook
+          Notify.success("#{parent_notebook.stack}/#{parent_notebook.name}/#{our_note.title} created")
+        else
+          Notify.success("DEFAULT_NOTEBOOK/#{our_note.title} created")
+        end
+
+        output
+      end
+
+      def generate_stats
+        {
+          "Statistic description" => 9845.3894
+        }
+      end
+
+      private
+        # Legacy notes will have single/double character denotations for day of
+        # week, this maps them.
+        def day_of_week
+          case Date.today.strftime('%a')
+          when 'Mon'
+            :M
+          when 'Tue'
+            :Tu
+          when 'Wed'
+            :W
+          when 'Thu'
+            :Th
+          when 'Fri'
+            :F
+          end
+        end
+
+        def template_contents
+          if Date.today.friday? && $request.command == :daily
+            # Friday uses a slightly different template
+            IO.readlines("#{Granify::TEMPLATE_DIR}#{$request.command}-friday.enml").join("").gsub!("\n", '')
+          else
+            IO.readlines("#{Granify::TEMPLATE_DIR}#{$request.command}.enml").join("").gsub!("\n", '')
+          end
+        end
+
+        def date_templates
+          now = DateTime.now
+          end_of_week = now + 4 # days
+          
+          {
+            :daily => "Daily Log [#{now.strftime('%B %-d')} - #{day_of_week}]",
+            :weekly => "Weekly Log [#{now.strftime('%B %-d')} - #{end_of_week.strftime('%B %-d')}]",
+            :monthly => "Monthly Log [#{now.strftime('%B %Y')}]"
+          }
+        end
+    end
+  end
+  end

data/lib/helpers/generate.rb

@@ -0,0 +1,39 @@
+module Granify
+  module Helper
+    class Generate
+      def self.format_date(title)
+        if title =~ /Daily/
+          resp = /Daily Log \[([A-Z].*) \- [A-Z]\]/.match(title)
+
+          if resp
+            Time.parse($1)
+          end
+        elsif title =~ /Weekly/
+          resp = /Weekly Log \[([A-Z].*) (\d+) \- (\d+)\]/.match(title)
+          
+          if resp
+            first = Time.parse($1 +" "+ $2)
+            second = Time.parse($1 +" "+ $3)
+
+            [first, second]
+          end
+        elsif title =~ /Monthly/
+          resp = /Monthly Log \[([A-Z].*) (\d+)\]/.match(title)
+
+          if resp
+            Time.parse($1 +" "+ $2)
+          end
+        elsif title =~ /Quarterly/
+          resp = /Quarterly Log \[([A-Z].*) \- ([A-Z].*) (\d+)\]/.match(title)
+
+          if resp
+            first = Time.parse($1 +" "+ $3)
+            second = Time.parse($2 +" "+ $3)
+
+            [first, second]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/helpers/time.rb

@@ -0,0 +1,28 @@
+module Granify
+  module Helper
+    class Time
+      def self.human_readable(start, finish)
+        seconds = finish.to_f - start.to_f
+
+        if seconds < 60
+          "No time at all!"
+        else
+          minutes = (seconds / 60).round(1)
+          if minutes < 1
+            "#{minutes} minute"
+          else
+            "#{minutes} minutes"
+          end
+        end
+      end
+
+      def self.formatted(time = nil)
+        if time.nil?
+          time = ::Time.now
+        end
+        
+        time.strftime("%e/%-m/%Y @ %I:%M:%S%P")
+      end
+    end
+  end
+end

data/lib/log.rb

@@ -0,0 +1,111 @@
+module Granify
+  class Log
+    attr_accessor :path, :total_files_processed
+    attr_reader :template
+
+    def initialize(*args)
+      if args.length == 0
+        # default log
+        @template = "#{Granify::LOG_DIR}/%s"
+        @path = sprintf(@template, "default.log")
+      else
+        @template = "#{Granify::LOG_DIR}/%s/%s-%s.log"
+        
+        format(args)
+      end
+
+      @path
+    end
+
+    def stale?
+      Time.now - last_write > 60
+    end
+
+    def exists?
+      File.exist? @path
+    end
+
+    def delete
+      if exists?
+        File.delete @path
+      end
+
+      Notify.sinfo("Deleting truncated log file #{@path}")
+      @path = nil
+    end
+
+    def num_lines
+      File.foreach(@path).inject(0) {|c, line| c+1}
+    end
+
+    def faults
+      matchdata = { :errors => 0, :warnings => 0, :total => 0 }
+
+      begin
+        case @log_type
+        when :js
+          last_line = IO.readlines(@path)[-5].chomp
+          matches = last_line.match(/(\d+) example, (\d+) failure/)
+          
+          if matches
+            matchdata[:errors] += matches[2].to_i
+          end
+        when :coffeelint
+          total = 0
+          File.foreach(@path) do |line|
+            matches = line.match(/Lint\! » (\d+) errors and (\d+)/)
+
+            if matches
+              matchdata[:errors] += matches[1].to_i
+              matchdata[:warnings] += matches[2].to_i
+            end
+          end
+        when :ruby
+          last_line = IO.readlines(@path)[-1].chomp
+          matches = last_line.match(/(\d+) files inspected\, (\d+)/)
+
+          if matches
+            matchdata[:errors] += matches[2].to_i
+            matchdata[:total] += matches[1].to_i
+          end
+        when :goliath
+
+        else
+          raise ArgumentError, "Unknown log type - #{log_type}"
+        end
+      rescue => e
+        Notify.error(e.message)
+      end
+
+      matchdata
+    end
+
+    def to_s
+      @path
+    end
+
+    private
+      def format(args)
+        @identifier = args[2]
+
+        @path = sprintf(@template,
+          @identifier,
+          args[0],
+          args[1].strftime('%Y-%m-%d-%T')
+          )
+
+        if !File.exists? @path
+          Utils.generate_path(args[0], args[1].strftime('%Y-%m-%d-%T'), @identifier)
+        end
+
+        # create the log file, populate it with temporary data
+        File.open(@path, 'w+') do |f|
+          f.write("Command output will be logged below when it finishes running\n")
+        end
+      end
+
+      def last_write
+        File.mtime(@path)
+      end
+  end
+end