evertils 0.0.1

data/lib/logs.rb

@@ -0,0 +1,34 @@
+module Granify
+  class Logs
+    MAX_LOGS_TO_STORE = 30
+
+    @files = Dir["#{Granify::LOG_DIR}/*/*.log"]
+
+    def self.clean
+      if @files.size > 0
+        @files.each do |file|
+          File.delete file if File.exist? file
+        end
+        Notify.info("Removed #{@files.size} old log files")
+      end
+    end
+
+    def self.dirty?
+      @files.size >= MAX_LOGS_TO_STORE
+    end
+
+    # Create a directory if required
+    def self.mkdir(name)
+      dir = "#{Granify::LOG_DIR}/#{name.downcase}"
+
+      if !Dir.exist? dir
+        Dir.mkdir dir
+      end
+
+      # Create the default .gitignore
+      File.open("#{dir}/.gitignore", "w+") do |file|
+        file.write "# Ignore everything in this directory\n*\n# Except this file\n!.gitignore"
+      end
+    end
+  end
+end

data/lib/model.rb

@@ -0,0 +1,26 @@
+module Granify
+  module Model
+    class Base
+      attr_accessor :data, :branch, :browser, :command, :start
+
+      def initialize(hash = nil)
+        @data = hash || Granify::Model::Data.new
+
+        # Current time
+        #@time = @data.start
+        # Time the command was executed
+        @start = Time.now
+        # Current working branch
+        @branch = @data.branch
+        # Browser to execute tests in
+        @browser = @data.browser
+        # Instantiate the command execution class
+        @command = Command::Exec.new
+      end
+
+      def bind(hash)
+        initialize(hash)
+      end
+    end
+  end
+end

data/lib/model_data.rb

@@ -0,0 +1,97 @@
+module Granify
+  module Model
+    class Data
+      attr_accessor :identifier, :branch, :browser, :files_with_errors
+
+      def initialize()
+        @d = Hash.new([])
+
+        # setup defaults
+        defaults = {
+          :issues => {:errors => 0, :warnings => 0},
+          :status => {:success => 0, :error => 0, :total => 0, :errors_per_file => 0},
+          :success_rate => {:int => 0, :str => "0%"},
+          :log => '',
+          :below_acceptable_limit => false
+        }
+
+        @branch = Command::Exec.git_current_branch
+        @files_with_errors = []
+
+        @d.merge! defaults
+      end
+
+      def unset(key)
+        @d.delete(key.to_sym)
+      end
+
+      def instance_var(key, val = nil)
+        self.class.__send__(:attr_accessor, key)
+        instance_variable_set("@#{key}", val)
+      end
+
+      def serialize
+        @d.to_json
+      end
+
+      def status
+        get(:status)
+      end
+
+      def success_rate
+        get(:success_rate)
+      end
+
+      def increment_issues(key, val)
+        @d[:issues][key.to_sym] += val
+      end
+
+      def increment_status(key, val)
+        @d[:status][key.to_sym] += val
+      end
+
+      def issues
+        get(:issues)
+      end
+
+      def issues=(val)
+        set(:issues, val)
+      end
+
+      def log
+        get(:log, Granify::DEFAULT_LOG)
+      end
+
+      def add_to_error_list(file)
+        @files_with_errors << file
+      end
+
+      def identifier=(val)
+        @identifier = val
+
+        # create the log file now
+        @d[:log] = Log.new(@branch, Time.now, @identifier)
+      end
+
+      def below_acceptable_limit?
+        get(:below_acceptable_limit) == true
+      end
+
+      def below_acceptable_limit=(val)
+        set(:below_acceptable_limit, val)
+      end
+
+      def bind!(seed_data)
+        @d = seed_data
+      end
+
+      def get(key, default = @d.default)
+        @d[key] || default
+      end
+
+      def set(key, val = nil)
+        @d[key] = val
+      end
+    end
+  end
+end

data/lib/request.rb

@@ -0,0 +1,20 @@
+module Granify
+  class Request
+    attr_reader :controller, :command, :custom, :flags, :raw_flags
+
+    def initialize
+      @controller = ARGV[0].to_sym rescue nil
+      
+      if ARGV.size > 1
+        @command = ARGV[1].to_sym rescue nil
+
+        if ARGV.size > 2
+          @custom = ARGV[2..ARGV.size].select { |p| !p.start_with?('-') }.map &:to_sym || []
+          # TODO: parameterize flag key/values
+          @flags = ARGV[2..ARGV.size].select { |f| f.start_with?('-') }.map { |f| f.split("=").map &:to_sym } || []
+          @raw_flags = ARGV[2..ARGV.size].select { |f| f.start_with?('-') } || []
+        end
+      end
+    end
+  end
+end

data/lib/router.rb

@@ -0,0 +1,73 @@
+module Granify
+  class Router
+    def route
+      # Populate request params
+      $request = Request.new
+
+      # include the controller
+      if File.exists? "#{Granify::CONTROLLER_DIR}#{$request.controller}.rb"
+        require "#{Granify::CONTROLLER_DIR}#{$request.controller}.rb"
+      end
+
+      # include helpers
+      if File.exists? "#{Granify::HELPER_DIR}#{$request.controller}.rb"
+        require "#{Granify::HELPER_DIR}#{$request.controller}.rb"
+      end
+
+      # include models
+      if File.exists? "#{Granify::MODEL_DIR}#{$request.controller}.rb"
+        require "#{Granify::MODEL_DIR}#{$request.controller}.rb"
+      end
+
+      # Create object context and pass it the required command line arguments
+      begin
+        controller = Granify::Controller.const_get $request.controller.capitalize rescue false
+        
+        if !controller
+          raise "Controller not found: #{$request.controller.capitalize}"
+        end
+
+        context = controller.new
+
+        if context.can_exec? $request.controller, $request.command
+          context.pre_exec
+
+          # no command sent?  Use default to populate model data
+          model_method = ($request.command ? $request.command : context.default_method).to_s + "_data"
+
+          # populate model data
+          method = context.model.public_method(model_method) rescue false
+
+          # model is not set, use Base model instead so the controller still has
+          # access to model methods
+          if context.model.nil?
+            context.model = Model::Base.new
+          end
+          
+          # If the method exists, set model data accordingly
+          # If it doesn't exist then just fail silently, the model may not
+          # be required by some controllers
+          if method.respond_to? :call
+            context.model.data = method.call($request.custom || [])
+          end
+
+          if context.methods_require_internet.include? $request.command
+            if !Utils.has_internet_connection?
+              raise RuntimeError, "Command `#{Granify::PACKAGE_NAME} #{$request.controller} #{$request.command}` requires a connection to the internet.\nPlease check your network configuration settings."
+            end
+          end
+
+          # Run the controller
+          context.exec
+
+          # Run cleanup commands
+          context.post_exec
+        end
+      rescue RuntimeError => e
+        Notify.error("#{e.to_s}")
+      rescue NameError => e
+        Notify.error("#{e.to_s}\n#{e.backtrace.join("\n")}")
+      end
+    end
+  end
+end

data/lib/utils.rb

@@ -0,0 +1,123 @@
+module Granify
+  class Utils
+    @cache = Hash.new
+    
+    # Gets a list of files from the current directory with a specific extension
+    def self.get_files(ext)
+      @cache[:files] ||= Hash.new
+      @cache[:files][ext] ||= []
+
+      Dir["*.#{ext}"].each do |file|
+        @cache[:files][ext].push file
+      end
+
+      @cache[:files][ext]
+    end
+
+    # Gets a list of all files in the project with a specific extension
+    def self.get_all_files(ext, ignore_paths = '')
+      @cache[:files] ||= Hash.new
+      @cache[:files][ext] ||= []
+
+      if @cache[:files][ext].empty?
+        Dir["**/*.#{ext}"].each do |file|
+          if !ignore_paths.empty?
+            # file is a widget
+            if /\/#{ignore_paths}/.match(file)
+              @cache[:files][ext].push file
+            end
+          else
+            # file is not a widget
+            @cache[:files][ext].push file
+          end
+        end
+      end
+
+      @cache[:files][ext]
+    end
+
+    # Gets a list of files from the current git commit queue with a specific
+    # extension
+    def self.get_files_from_git(ext)
+      @cache[:files] ||= Hash.new
+      @cache[:files][ext] ||= []
+
+      modified_files = `git status --porcelain`.split("\n")
+      modified_files.each do |file|
+        if file.match(/#{ext}/)
+          @cache[:files][ext].push file.strip.match(/[A-Z ]+(.*)/)[1]
+        end
+      end
+      
+      @cache[:files][ext]
+    end
+
+    # Generate a filename
+    def self.generate_path(branch, time, identifier)
+      # create the directory if needed
+      Logs.mkdir identifier
+
+      # create a new log file with a path based on the input parameters
+      #Log.new(identifier, branch, time)
+    end
+
+    # Convert hash keys to symbols
+    def self.symbolize_keys(hash)
+      Hash[hash.map{ |k, v| [k.to_sym, v] }]
+    end
+
+     # Create a directory wherever the script is called from, if required
+    def self.mklocaldir(name)
+      dir = "#{Dir.pwd}/#{name.downcase}/"
+
+      if !Dir.exist? dir
+        Dir.mkdir dir
+      else
+        dir
+      end
+    end
+
+    def self.os
+      begin
+        @os ||= (
+          host_os = RbConfig::CONFIG['host_os']
+          case host_os
+          when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+            :windows
+          when /darwin|mac os/
+            :macosx
+          when /linux/
+            :linux
+          when /solaris|bsd/
+            :unix
+          else
+            raise TypeError, "unknown os: #{host_os.inspect}"
+          end
+        )
+      rescue err
+        Notify.error(err.message)
+      end
+    end
+
+    def self.json?(string)
+      begin
+        !!JSON.parse(string)
+      rescue
+        false
+      end
+    end
+
+    def self.http_response_code(url = nil)
+      begin
+        request = Net::HTTP.get_response(URI.parse(url || "http://google.com"))
+        request.code.to_i
+      rescue
+        500
+      end
+    end
+
+    def self.has_internet_connection?
+      Utils.http_response_code < 499
+    end
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: evertils
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ryan Priebe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-03 00:00:00.000000000 Z
+dependencies: []
+description: Evernote utilities for your CLI workflow
+email: hello@ryanpriebe.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/command.rb
+- lib/config.rb
+- lib/configs/templates/daily-friday.enml
+- lib/configs/templates/daily.enml
+- lib/configs/templates/monthly.enml
+- lib/configs/templates/quarterly.enml
+- lib/configs/templates/weekly.enml
+- lib/constants.rb
+- lib/controller.rb
+- lib/controllers/convert.rb
+- lib/controllers/generate.rb
+- lib/controllers/get.rb
+- lib/controllers/new.rb
+- lib/helper.rb
+- lib/helpers/evernote-enml.rb
+- lib/helpers/evernote-markdown.rb
+- lib/helpers/evernote.rb
+- lib/helpers/generate.rb
+- lib/helpers/time.rb
+- lib/log.rb
+- lib/logs.rb
+- lib/model.rb
+- lib/model_data.rb
+- lib/request.rb
+- lib/router.rb
+- lib/utils.rb
+homepage: http://rubygems.org/gems/evertils
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: EN (heart) CLI
+test_files: []