evertils 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 136d79a7dda1df2c273df2fb0e228da3e71f3a29
+  data.tar.gz: c83fea36ee66af27bd096e6c42431c1a45d15137
+SHA512:
+  metadata.gz: 88a6de1348dbeb8b6c44acf49a8b9a6ea1e0c3a349d47a962760b9254b533eb26aaa6e41759b7412ff411522064a272770f3073ccb8657932188039803ffaf2a
+  data.tar.gz: a4cfaaae6c4f1a0d8f6f146c497262270e5047dadcd290e348d73a5804a4dd048e849a90c6281cbb65d38861de401d4a9b4e0459c2988d0032e3893a40fc6b23

data/lib/command.rb

@@ -0,0 +1,179 @@
+module Granify
+  module Command
+    class Exec
+      attr_reader :response, :exitcode
+      attr_accessor :enable_logging
+
+      #
+      # class methods
+      #
+      class << self
+        def git_queue_status
+          if global("git log origin/#{git_current_branch}..HEAD --oneline")
+            response = @response.split("\n")
+            response.size > 0
+          end
+        end
+
+        def git_push
+          global("git push -q origin #{git_current_branch}")
+        end
+
+        def git_checkout
+          begin
+            curr_branch = git_current_branch
+            branch = $request.custom.nil? ? curr_branch : $request.custom[0]
+
+            if !git_branch_verify branch
+              raise "Requested branch not found in the working copy: #{branch}"
+            end
+
+            if branch == curr_branch
+              return Notify.warning("Requested branch is already checked out, skipping checkout")
+            else
+              global("git checkout -q #{branch}")
+            end
+
+            # not found locally, checkout from origin
+            if !@response
+              branch = "origin/#{branch}"
+              global("git checkout -q #{branch}")
+            end
+
+            if !@response
+              Notify.error("Unable to locate #{branch} on the remote server or local working copy")
+            end
+
+            branch
+          rescue SystemExit, Interrupt
+            Notify.error("Interrupt caught, exiting")
+          rescue RuntimeError => e
+            Notify.error(e.message)
+          end
+        end
+
+        def git_current_branch
+          global("git rev-parse --abbrev-ref HEAD")
+        end
+
+        def git_branch_verify(branch = nil)
+          if branch.nil?
+            branch = git_current_branch
+          end
+
+          global("git rev-parse --verify #{branch}")
+        end
+
+        def global(command, file = nil)
+          begin
+            # disable logging if user settings prohibit it
+            #file = nil if !@enable_logging
+            # default value for exit code is an error
+            @exitcode = 1
+
+            @response = `#{command}`.chomp
+            @exitcode = $?.exitstatus
+
+            # Log output to a file
+            # This method is better than redirecting output to a file because now
+            # the response is always populated instead of being empty when output
+            # is sent to the log file
+            if file
+              File.open(file.path, 'w+') do |f|
+                f.write(@response)
+              end
+            end
+
+            @response
+          rescue SystemExit, Interrupt
+            Notify.error("Interrupt caught, exiting")
+          end
+        end
+      end
+
+      #
+      # instance methods
+      #
+      def minify(file, destination)
+        begin
+          min_file = "#{destination}#{File.basename(file, File.extname(file))}.min.js"
+
+          @response = `uglifyjs #{file} -cm -o "#{min_file}"`
+
+          Notify.success("Minified #{file}")
+
+          $?.exitstatus == 0
+        rescue SystemExit, Interrupt
+          Notify.error("Interrupt caught, exiting")
+        end
+      end
+
+      def lint(file, log_file)
+        begin
+          command = `coffeelint -f "#{Granify::INSTALLED_DIR}/lib/configs/coffeelint.json" #{file}`
+
+          @response = command.include?("Ok!")
+
+          # only send errors to the log file
+          if !@response
+            File.open(log_file.path, 'a') do |f|
+              f.write("Logged at #{Time.now}\n============================================================\n\n")
+              f.write(command)
+            end
+          end
+
+          $?.exitstatus == 0
+        rescue SystemExit, Interrupt
+          Notify.error("Interrupt caught, exiting")
+        end
+      end
+
+      def open_editor(file=nil)
+        begin
+          log_file = file || Granify::DEFAULT_LOG
+
+          # System editor is not set/unavailable, use system default to open the
+          # file
+          if `echo $EDITOR` == ""
+            if Utils.os == :macosx
+              `open #{log_file.path}`
+            else
+              `xdg-open #{log_file.path}`
+            end
+          else
+            `$EDITOR #{log_file.path}`
+          end
+        rescue SystemExit, Interrupt
+          Notify.error("Interrupt caught, exiting")
+        end
+      end
+
+      def arbitrary(command, file = nil)
+        begin
+          # default value for exit code is an error
+          @exitcode = 1
+          @response = `#{command}`.chomp
+          @exitcode = $?.exitstatus
+
+          # Log output to a file
+          # This method is better than redirecting output to a file because now
+          # the response is always populated instead of being empty when output
+          # is sent to the log file
+          if file
+            File.open(file.path, 'w+') do |f|
+              f.write("Logged at #{Time.now}\n============================================================\n\n")
+              f.write(@response)
+            end
+          end
+
+          @exitcode == 0
+
+          # support chaining
+          self
+        rescue SystemExit, Interrupt
+          Notify.error("Interrupt caught, exiting")
+        end
+      end
+    end
+  end
+end

data/lib/config.rb

@@ -0,0 +1,14 @@
+module Granify
+  class Cfg
+    def bootstrap!
+      begin
+        # configure Notifaction gem
+        Notify.configure do |c|
+          c.plugins = []
+        end
+      rescue => e
+        Notify.error("#{e.to_s}\n#{e.backtrace.join("\n")}")
+      end
+    end
+  end
+end

data/lib/configs/templates/daily-friday.enml

@@ -0,0 +1,14 @@
+<div><span style="font-size: 18px;">Logs</span></div>
+<ul>
+<li>...</li>
+</ul>
+<br />
+<div><span style="font-size: 18px;">Tasks completed</span></div>
+<ul>
+<li>...</li>
+</ul>
+<br />
+<div><span style="font-size: 18px;">EOD</span></div>
+<div><en-todo checked="false"/><a href="https://granify2000.harvestapp.com/">Harvest</a></div>
+<div><en-todo checked="false"/><a href="https://docs.google.com/a/granify.com/spreadsheets/d/1tYFS_Yy-6bMQyn5VPBfg2yXRRA3kYrRcwq1hS1jfG2w/edit#gid=0">Fill out expense report</a></div>
+<div><en-todo checked="false"/>Update meeting notes</div>

data/lib/configs/templates/daily.enml

@@ -0,0 +1,9 @@
+<div><span style="font-size: 18px;">Logs</span></div>
+<ul>
+<li>...</li>
+</ul>
+<br />
+<div><span style="font-size: 18px;">Tasks completed</span></div>
+<ul>
+<li>...</li>
+</ul>

data/lib/configs/templates/monthly.enml

@@ -0,0 +1,21 @@
+<ul>
+<li>...</li>
+</ul>
+<div>
+<div><br/></div>
+<div><span style="font-size: 18px;">Highlights</span></div>
+<div>
+<ul>
+<li>...</li>
+</ul>
+<div>
+<div><br/></div>
+<div><span style="font-size: 18px;">Weekly Goals</span></div>
+</div>
+<ul>
+<li><en-todo/>...</li>
+</ul>
+<br />
+<div><span style="font-size: 18px;">Quarterly Goals</span></div>
+</div>
+</div>

data/lib/configs/templates/weekly.enml

@@ -0,0 +1,18 @@
+<div>
+<div><span style="font-size: 18px;">Logs</span></div>
+<ul>
+<li>...</li>
+</ul>
+</div>
+<div>
+<div><br/></div>
+<div><span style="font-size: 18px;">Highlights</span></div>
+<ul>
+<li>...</li>
+</ul>
+<div><br/></div>
+<div><span style="font-size: 18px;">Goals</span></div>
+</div>
+<ul>
+<li>...</li>
+</ul>

data/lib/constants.rb

@@ -0,0 +1,12 @@
+module Granify
+  PACKAGE_NAME = "evertils"
+  INSTALLED_DIR = File.dirname($0)
+  LOG_DIR = INSTALLED_DIR + "/logs"
+  DEFAULT_LOG = Log.new # no args means default log
+  HELPER_DIR = INSTALLED_DIR + "/lib/helpers/"
+  CONTROLLER_DIR = INSTALLED_DIR + "/lib/controllers/"
+  MODEL_DIR = INSTALLED_DIR + "/lib/models/"
+  TEMPLATE_DIR = INSTALLED_DIR + "/lib/configs/templates/"
+  LOG_DIGEST_LENGTH = 20
+  DEBUG = false
+end

data/lib/controller.rb

@@ -0,0 +1,113 @@
+module Granify
+  module Controller
+    class Base
+      attr_accessor :model, :helper, :methods_require_internet, :default_method
+
+      @@options = Hash.new
+      
+      # Perform pre-run tasks
+      def pre_exec
+        OptionParser.new do |opt|
+          opt.banner = "#{Granify::PACKAGE_NAME} controller command [...-flags]"
+
+          opt.on("-v", "--verbose", "Verbose output") do |v|
+            # short output
+            @@options[:verbose] = v
+          end
+        end.parse!
+      end
+
+      # Handle the request
+      def exec(args = [])
+        self.send(@default_method.to_sym)
+      end
+
+      # Perform post-run cleanup tasks, such as deleting old logs
+      def post_exec(total_errors = 0, total_warnings = 0, total_files = 0)
+        
+      end
+
+      # Determines if the command can execute
+      def can_exec?(command = nil, name = nil)
+        @model = Granify::Model.const_get(command.capitalize).new rescue nil
+        @helper = Granify::Helper.const_get(command.capitalize).new rescue nil
+        @methods_require_internet = []
+
+        # get user-defined methods to use as a fallback
+        user_defined_methods = []
+
+        # timeout is the first system defined method after the user defined
+        # ones
+        for i in 0..public_methods.index(:to_json) -1
+          user_defined_methods.push(public_methods[i].to_sym)
+        end
+
+        @default_method = name || user_defined_methods.first || :sample
+
+        if !respond_to? default_method.to_sym, true
+          Notify.error("Command not found: #{name}")
+        end
+
+        true
+      end
+
+      # default method called by exec if no argument is passed
+      def sample
+        Notify.warning("Method not implemented");
+      end
+
+      def required_modules(*modules)
+        auto_load_required(modules).each do |type, hash|
+          # Make each auto-loaded module available as an instance variable
+          # i.e. [:hound]: @hound_controller, @hound_model, @hound_helper
+          # i.e. [:test]: @test_controller, @test_model, @test_helper
+          # Only files that exist and can be called are loaded
+          hash.each do |key, value|
+            instance_variable_set("@#{key}_#{type}".to_sym, value)
+            @last_model = instance_variable_get("@#{key}_model")
+          end
+        end
+      end
+
+      private
+        # autoload and instantiate required libraries, models and helpers
+        def auto_load_required(modules = [])
+          loaded = {:controller => {}, :helper => {}, :model => {}}
+          
+          begin
+            modules.each do |mod|
+              if File.exists? "#{Granify::INSTALLED_DIR}/lib/controllers/#{mod}.rb"
+                require "#{Granify::INSTALLED_DIR}/lib/controllers/#{mod}.rb"
+                
+                loaded[:controller][mod] = Granify::Controller.const_get(mod.capitalize).new
+              else
+                raise StandardError, "Controller not found: #{mod}"
+              end
+
+              if File.exists? "#{Granify::INSTALLED_DIR}/lib/helpers/#{mod}.rb"
+                require "#{Granify::INSTALLED_DIR}/lib/helpers/#{mod}.rb"
+                loaded[:helper][mod] = Granify::Helper.const_get(mod.capitalize).new
+
+                # auto-instantiate new instance of helper for the new instance of the controller
+                loaded[:controller][mod].helper = loaded[:helper][mod]
+              end
+
+              if File.exists? "#{Granify::INSTALLED_DIR}/lib/models/#{mod}.rb"
+                require "#{Granify::INSTALLED_DIR}/lib/models/#{mod}.rb"
+                loaded[:model][mod] = Granify::Model.const_get(mod.capitalize).new
+
+                # auto-instantiate new instance of model for the new instance of the controller
+                loaded[:controller][mod].model = loaded[:model][mod]
+              else
+                loaded[:controller][mod].model = Model::Base.new
+              end
+            end
+
+            loaded
+          rescue StandardError => e
+            Notify.error(e.message)
+          end
+        end
+    end
+  end
+end

data/lib/controllers/convert.rb

@@ -0,0 +1,63 @@
+module Granify
+  module Controller
+    class Convert < Controller::Base
+      attr_accessor :title, :file, :notebook
+
+      def pre_exec
+        begin
+          # interface with the Evernote API so we can use it later
+          @model = Granify::Helper.load('evernote')
+
+          # all methods require internet to make API calls
+          @methods_require_internet.push(:daily, :weekly, :monthly)
+
+          # command flag parser
+          OptionParser.new do |opt|
+            opt.banner = "#{Granify::PACKAGE_NAME} new note [...-flags]"
+
+            opt.on("-m", "--to-markdown", "Convert to MD format") do |b|
+              @markdown = b
+            end
+
+            opt.on("-e", "--to-enml", "Convert to ENML") do |b|
+              @file = b
+            end
+
+            opt.on("-n", "--notebook=PBOOK", "Attach a file to your custom note") do |notebook|
+              @notebook = notebook.capitalize
+            end
+          end.parse!
+
+          # user = @model.user
+          # Notify.success("Welcome, #{user.name} (#{user.username})")
+        rescue ::Evernote::EDAM::Error::EDAMSystemException => e
+          Notify.error("Evernote.authenticate error\n#{e.message} (#{e.errorCode})")
+        rescue ::Evernote::EDAM::Error::EDAMUserException => e
+          Notify.error("Evernote.authenticate error\n#{e.parameter} (#{e.errorCode})")
+        end
+
+        super
+      end
+
+      def notes_in
+        unless @notebook
+          Notify.error("Notebook (--notebook=) is a required argument")
+        end
+
+        metadata = @model.notes_by_notebook(@notebook)
+
+        if metadata.is_a? Hash
+          Notify.info("#{metadata.size} notes in #{@notebook}")
+          Notify.info("Printing list of notes")
+
+          metadata.each_pair do |note_guid, note_content|
+            # convert it here!
+            puts note_content
+          end
+        else
+          Notify.error("Could not pull data for notebook #{@notebook}")
+        end
+      end
+    end
+  end
+end

data/lib/controllers/generate.rb

@@ -0,0 +1,51 @@
+module Granify
+  module Controller
+    class Generate < Controller::Base
+      def pre_exec
+        begin
+          # interface with the Evernote API so we can use it later
+          @model = Granify::Helper.load('evernote')
+
+          # all methods require internet to make API calls
+          @methods_require_internet.push(:daily, :weekly, :monthly)
+
+          # user = @model.user
+          # Notify.success("Welcome, #{user.name} (#{user.username})")
+        rescue ::Evernote::EDAM::Error::EDAMSystemException => e
+          Notify.error("Evernote.authenticate error\n#{e.message} (#{e.errorCode})")
+        rescue ::Evernote::EDAM::Error::EDAMUserException => e
+          Notify.error("Evernote.authenticate error\n#{e.parameter} (#{e.errorCode})")
+        end
+
+        super
+      end
+
+      # generate daily notes
+      def daily
+        if @model.note_exists
+          Notify.error("There's already a log for today!")
+        end
+
+        @model.create_note
+      end
+
+      # generate weekly notes
+      def weekly
+        if @model.note_exists
+          Notify.error("There's already a log for this week!")
+        end
+
+        @model.create_note
+      end
+
+      # generate monthly notes
+      def monthly
+        if @model.note_exists
+          Notify.error("There's already a log for this month!")
+        end
+
+        @model.create_note
+      end
+    end
+  end
+end

data/lib/controllers/get.rb

@@ -0,0 +1,70 @@
+module Granify
+  module Controller
+    class Get < Controller::Base
+      attr_accessor :title, :file, :notebook
+
+      def pre_exec
+        begin
+          # interface with the Evernote API so we can use it later
+          @model = Granify::Helper.load('evernote')
+
+          # all methods require internet to make API calls
+          @methods_require_internet.push(:daily, :weekly, :monthly)
+
+          # command flag parser
+          OptionParser.new do |opt|
+            opt.banner = "#{Granify::PACKAGE_NAME} new note [...-flags]"
+
+            opt.on("-t", "--title=TITLE", "Set a custom title") do |title|
+              @title = title
+            end
+
+            opt.on("-f", "--file=PATH", "Attach a file to your custom note") do |file|
+              @file = file
+            end
+
+            opt.on("-n", "--notebook=PBOOK", "Attach a file to your custom note") do |notebook|
+              @notebook = notebook
+            end
+          end.parse!
+
+          # user = @model.user
+          # Notify.success("Welcome, #{user.name} (#{user.username})")
+        rescue ::Evernote::EDAM::Error::EDAMSystemException => e
+          Notify.error("Evernote.authenticate error\n#{e.message} (#{e.errorCode})")
+        rescue ::Evernote::EDAM::Error::EDAMUserException => e
+          Notify.error("Evernote.authenticate error\n#{e.parameter} (#{e.errorCode})")
+        end
+
+        super
+      end
+
+      # Get data about a notebook, prints titles of each child note
+      def notebook
+        if !$request.custom.nil?
+          book = $request.custom[0]
+          metadata = @model.notes_by_notebook(book)
+
+          if metadata.is_a? ::Evernote::EDAM::NoteStore::NotesMetadataList
+            Notify.info("#{metadata.totalNotes} notes in #{book}")
+            Notify.info("Printing list of notes")
+
+            metadata.notes.each do |note|
+              puts note.title
+            end
+          else
+            Notify.error("Could not pull data for notebook #{$request.custom[0]}")
+          end
+        else
+          Notify.error("Notebook name is a required argument, i.e.\n#{Granify::PACKAGE_NAME} get notebook agendas")
+        end
+      end
+
+      def info
+        @model.info.each_pair do |key, value|
+          Notify.spit("#{key}: #{value}")
+        end
+      end
+    end
+  end
+end

data/lib/controllers/new.rb

@@ -0,0 +1,88 @@
+module Granify
+  module Controller
+    class New < Controller::Base
+      attr_accessor :title, :file, :notebook
+
+      def pre_exec
+        begin
+          # interface with the Evernote API so we can use it later
+          @model = Granify::Helper.load('evernote')
+
+          # all methods require internet to make API calls
+          @methods_require_internet.push(:daily, :weekly, :monthly)
+
+          @title = "Evertils - Custom Note"
+
+          # command flag parser
+          OptionParser.new do |opt|
+            opt.banner = "#{Granify::PACKAGE_NAME} new note [...-flags]"
+
+            opt.on("-t", "--title=TITLE", "Set a custom title") do |title|
+              @title = title
+            end
+
+            opt.on("-f", "--file=PATH", "Attach a file to your custom note") do |file|
+              @file = file
+            end
+
+            opt.on("-n", "--notebook=PBOOK", "Attach a file to your custom note") do |notebook|
+              @notebook = notebook
+            end
+
+            opt.on("-b", "--body=BODY", "Note body") do |body|
+              @body = body
+            end
+          end.parse!
+
+          # user = @model.user
+          # Notify.success("Welcome, #{user.name} (#{user.username})")
+        rescue ::Evernote::EDAM::Error::EDAMSystemException => e
+          Notify.error("Evernote.authenticate error\n#{e.message} (#{e.errorCode})")
+        rescue ::Evernote::EDAM::Error::EDAMUserException => e
+          Notify.error("Evernote.authenticate error\n#{e.parameter} (#{e.errorCode})")
+        end
+
+        super
+      end
+
+      # Create a new Evernote note from data or terminal output
+      def note
+        if @body.nil?
+          message = JSON.parse(STDIN.gets).join
+          message = message.gsub!("\n", '<br />')
+        else
+          message = @body
+        end
+
+        note = @model.create_note(@title, message, @notebook, @file)
+
+        if note[:note]
+          Notify.success("Note created")
+        else
+          Notify.error("Unable to create note, are you authenticated?")
+        end
+      end
+
+      # Create a new note and automatically share it
+      def share_note
+        if @body.nil?
+          message = JSON.parse(STDIN.gets).join
+          message = message.gsub!("\n", '<br />')
+        else
+          message = @body
+        end
+
+        # Prefix title to indicate it's shared status
+        @title = "[SHARED] #{@title}"
+        
+        note = @model.create_note(@title, message, @notebook, @file, true)
+
+        if note[:share_url]
+          Notify.success("Note created and shared:\n#{note[:share_url]}")
+        else
+          Notify.error("Something dreadful happened!")
+        end
+      end
+    end
+  end
+end

data/lib/helper.rb

@@ -0,0 +1,19 @@
+module Granify
+  module Helper
+    def self.load(klass, args = nil)
+      begin
+        klass_instance = Granify::Helper.const_get(klass.capitalize)
+        
+        if klass_instance
+          if args.nil?
+            klass_instance.new
+          else
+            klass_instance.new(args)
+          end
+        end
+      rescue => e
+        Notify.error(e.message)
+      end
+    end
+  end
+end