conify 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1341bc6fcee246543d347268d052a9f4a54d8700
+  data.tar.gz: bcaab7d870a605f12ae094afad844e4f4e866873
+SHA512:
+  metadata.gz: 51a20b09d4b11d8bfc50eef1529fedd1666b9f0920ec46b3f920e46afba1840c4e35c63fe86f0c50e1d542c4c4c32dbc121a9606d721b643f8765c7758ce166a
+  data.tar.gz: a0dc663dc467fced8b6484a71b7b0d7859867ab14e0ba406707667017c516f70fbd0023d73f8e892ee88d08a32e7f6a1434e45f2d5caa3f62c9cddc133f25bbf

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.idea/
+/.conflux/
+/configs.yml
+/conflux-manifest.json

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.0.0
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in conify.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Ben Whittle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,9 @@
+# Conify
+
+## Contributing
+
+To contribute to this repo, submit a pull request or raise an issue in the issues section with an appropriate issue tag.
+
+## License
+
+[MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/conify

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+# Fixes https://github.com/rubygems/rubygems/issues/1420
+require 'rubygems/specification'
+
+class Gem::Specification
+  def this
+    self
+  end
+end
+
+# Create way to set config vars during development --> put them in configs.yml inside root of this project
+config_vars_path = File.expand_path(File.dirname(__FILE__) + '/../configs.yml')
+
+if File.exists?(config_vars_path)
+  require 'yaml'
+
+  configs = YAML::load_file(config_vars_path) rescue {}
+
+  (configs || {}).each { |key, val|
+    ENV[key] = val if !ENV.key?(key)
+  }
+end
+
+require 'conify/cli'
+
+Conify::CLI.start!(*ARGV)

data/config.ru

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.require :default, :development
+
+Combustion.initialize! :all
+run Combustion::Application

data/conify.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'conify/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "conify"
+  spec.version       = Conify::VERSION
+  spec.authors       = ["Ben Whittle"]
+  spec.email         = ["benwhittle31@gmail.com"]
+  spec.summary       = "A gem to help developer tools integrate their services with Conflux"
+  spec.homepage      = "https://www.github.com/GoConflux/conify"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = ["conify"]
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "mechanize", "~> 2.6.0"
+  spec.add_runtime_dependency "rest-client", "~> 2.0.0"
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry"
+end

data/lib/conify.rb

@@ -0,0 +1,2 @@
+module Conify
+end

data/lib/conify/api.rb

@@ -0,0 +1,4 @@
+module Conify
+  module Api
+  end
+end

data/lib/conify/api/abstract_api.rb

@@ -0,0 +1,78 @@
+require 'conify/api'
+require 'conify/helpers'
+require 'net/http'
+require 'net/https'
+require 'uri'
+require 'json'
+
+# Used to make requests to the Conflux API
+class Conify::Api::AbstractApi
+  include Conify::Helpers
+
+  def get(route, data: {}, headers: {}, error_message: 'Error making request', show_err_response: false)
+    form_request(Net::HTTP::Get, route, data, headers, error_message, show_err_response)
+  end
+
+  def post(route, data: {}, headers: {}, error_message: 'Error making request', show_err_response: false)
+    json_request(Net::HTTP::Post, route, data, headers, error_message, show_err_response)
+  end
+
+  def put(route, data: {}, headers: {}, error_message: 'Error making request', show_err_response: false)
+    json_request(Net::HTTP::Put, route, data, headers, error_message, show_err_response)
+  end
+
+  def delete(route, data: {}, headers: {}, error_message: 'Error making request', show_err_response: false)
+    form_request(Net::HTTP::Delete, route, data, headers, error_message, show_err_response)
+  end
+
+  def ssl_check_win(net_http)
+    case RUBY_PLATFORM
+      when /win/i, /ming/i
+        net_http.verify_mode = OpenSSL::SSL::VERIFY_NONE if net_http.use_ssl?
+    end
+  end
+
+  def http
+    uri = URI.parse(host_url)
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true if uri.scheme == 'https'
+    ssl_check_win(http)
+    http
+  end
+
+  def form_request(net_obj, route, data, headers, error_message, show_err_response)
+    route = data.empty? ? route : "#{route}?#{URI.encode_www_form(data)}"
+    request = net_obj.new("/api#{route}")
+    request.add_field('Content-Type', 'application/x-www-form-urlencoded')
+    add_headers(request, headers)
+    response = http.request(request)
+    handle_json_response(response, error_message, show_err_response)
+  end
+
+  def json_request(net_obj, route, data, headers, error_message, show_err_response)
+    request = net_obj.new("/api#{route}")
+    request.add_field('Content-Type', 'application/json')
+    add_headers(request, headers)
+    request.body = data.to_json
+    response = http.request(request)
+    handle_json_response(response, error_message, show_err_response)
+  end
+
+  def add_headers(request, headers = {})
+    headers.each { |key, val| request.add_field(key, val) }
+  end
+
+  def handle_json_response(response, error_message, show_err_response)
+    if response.code.to_i == 200
+      JSON.parse(response.body) rescue {}
+    else
+      if show_err_response
+        json_err = JSON.parse(response.body) rescue {}
+        error json_err['message'] || response.body
+      else
+        error error_message
+      end
+    end
+  end
+
+end

data/lib/conify/api/addons.rb

@@ -0,0 +1,19 @@
+require 'conify/api/abstract_api'
+
+class Conify::Api::Addons < Conify::Api::AbstractApi
+
+  def extension
+    '/addons'
+  end
+
+  # Push draft service to Conflux
+  def push(manifest, token)
+    post(
+      "#{extension}/push",
+      data: { manifest: manifest },
+      headers: { 'Conflux-User' => token },
+      show_err_response: true
+    )
+  end
+
+end

data/lib/conify/api/users.rb

@@ -0,0 +1,18 @@
+require 'conify/api/abstract_api'
+
+class Conify::Api::Users < Conify::Api::AbstractApi
+
+  def extension
+    '/users'
+  end
+
+  # Exchange email/password for Conflux user_token
+  def login(creds)
+    post(
+      "#{extension}/login",
+      data: creds,
+      error_message: "Invalid credentials.\nMake sure you have a valid Conflux account before proceeding."
+    )
+  end
+
+end

data/lib/conify/cli.rb

@@ -0,0 +1,29 @@
+require 'conify/helpers'
+
+module Conify
+  module CLI
+    extend Conify::Helpers
+
+    def self.start!(*args)
+      # Setup StdIn/StdOut sync
+      $stdin.sync = true if $stdin.isatty
+      $stdout.sync = true if $stdout.isatty
+
+      # Strip out command
+      command = args.shift.strip rescue 'help'
+
+      require 'conify/command'
+
+      # Find and run command if it exists
+      Conify::Command.find_command(command, args)
+
+    rescue Errno::EPIPE => e
+      error(e.message)
+    rescue Interrupt => e
+      error('Command cancelled.')
+    rescue => e
+      error(e)
+    end
+
+  end
+end

data/lib/conify/command.rb

@@ -0,0 +1,286 @@
+require 'conify/helpers'
+require 'conify/version'
+require 'optparse'
+require 'pathname'
+
+module Conify
+  module Command
+    extend Conify::Helpers
+    extend self
+
+    CMD_BLACKLIST = []
+
+    # Finds file/method for command
+    def find_command(cmd, args = [])
+      @current_cmd = cmd
+      @current_args = args
+
+      respond_with_help if seeking_help?
+      respond_with_version if seeking_version?
+
+      # Separate out primary/secondary commands based on if command was namespaced
+      # e.g. `conify services vs. conify services:add`
+      primary_cmd, secondary_cmd = @current_cmd.split(':')
+
+      # Get the command file path (string) for the primary command
+      primary_cmd_file = file_for_command(primary_cmd)
+
+      # If the primary command has it's own file, require it
+      primary_cmd_file_exists = File.exists?(primary_cmd_file)
+      require primary_cmd_file if primary_cmd_file_exists
+
+      # If a secondary command exists, the primary_cmd_file must be where our command method lies
+      if !secondary_cmd.nil?
+        error_no_command if !primary_cmd_file_exists
+
+        # Get command_klass for file path. Example response --> Conify::Command::Services
+        command_klass = klass_for_file(primary_cmd_file)
+
+        # Error out if the command klass doesn't have a method named <secondary_cmd>
+        error_no_command if !klass_has_method?(command_klass, secondary_cmd)
+
+        run(command_klass, secondary_cmd)
+
+      # If there's no secondary command, there are 2 options for where the command method could be (in order of priority):
+      # (1) Inside the primary command file as the 'index' method
+      # (2) Inside the global command file, as a method named <primary_cmd>
+      else
+        # Store lambda for later
+        try_global = lambda {
+          require 'conify/command/global'
+          command_klass = Conify::Command::Global
+          error_no_command if !klass_has_method?(command_klass, primary_cmd)
+          run(command_klass, primary_cmd)
+        }
+
+        # Number 1 above. If primary_cmd file exists, call the index method on it if it exists.
+        # If index method doens't exist, check to see if method is a global command.
+        if primary_cmd_file_exists
+          # Get command_klass for file path. Example response --> Conify::Command::Services
+          command_klass = klass_for_file(primary_cmd_file)
+
+          klass_has_method?(command_klass, 'index') ? run(command_klass, 'index') : try_global.call
+
+        # Number 2 above. Check to see if method is a global command inside command/global.rb
+        else
+          try_global.call
+        end
+      end
+    end
+
+    # Call a method on a klass with certain arguments.
+    # Will validate arguments first before calling method.
+    def run(klass, method)
+      # Get the command info for this method on this klass
+      command_info_module = klass::CommandInfo.const_get(camelize(method))
+
+      # If seeking help for this command with --help or -h
+      if seeking_command_help?(@current_args)
+        puts "\nPurpose: #{command_description(command_info_module)}\n"
+
+        # respond with command-specific help
+        respond_with_command_help(command_info_module)
+        return
+      end
+
+      # get the valid arguments defined for this comand
+      valid_args = command_valid_args(command_info_module)
+
+      if !valid_args?(valid_args)
+        handle_invalid_args(command_info_module)
+        return
+      end
+
+      klass.new(@current_args.dup).send(method)
+    end
+
+    # Get a command klass back from a file path:
+    # Example I/O: 'command/bundles' --> Conify::Command::Bundles
+    def klass_for_file(file)
+      # Get basename for the file without the extension
+      basename = get_basename_from_file(file)
+
+      # Camelcase the basename to be the klass name
+      klass_name = camelize(basename)
+
+      # return the command klass for this klass_name
+      Conify::Command.const_get(klass_name)
+    end
+
+    # Create a command file path from the name of a command
+    def file_for_command(command)
+      File.join(File.dirname(__FILE__), 'command', "#{command}.rb")
+    end
+
+    # Check to see if user-defined method exists on a klass
+    def klass_has_method?(klass, method)
+      manually_added_methods(klass).include?(method.to_sym)
+    end
+
+    def error_no_command
+      error([
+        "`#{@current_cmd}` is not a conify command.",
+        "Type `conify help` for a list of available commands."
+      ].compact.join("\n"))
+    end
+
+    # Check if passed-in arguments are valid for a specific format
+    def valid_args?(accepted_arg_formats)
+      valid_args = false
+
+      accepted_arg_formats.each { |format|
+        # if no arguments exist, and no arguments is an accepted format, args are valid.
+        if format.empty? && @current_args.empty?
+          valid_args = true
+        else
+          passed_in_args = @current_args.clone
+
+          format.each_with_index { |arg, i|
+            passed_in_args[i] = arg if CMD_BLACKLIST.include?(arg)
+          }
+
+          @invalid_args = passed_in_args - format - [nil]
+
+          valid_args = true if passed_in_args == format
+        end
+      }
+
+      valid_args
+    end
+
+    # Respond to the user in the instance of invalid arguments.
+    def handle_invalid_args(command_info_module)
+      if !@invalid_args.empty?
+        message = 'Invalid argument'
+        message += 's' if @invalid_args.length > 1
+        args = @invalid_args.map { |arg| "\"#{arg}\"" }.join(', ')
+
+        puts " !    #{message}: #{args}"
+      else
+        puts " !    Invalid command usage"
+      end
+
+      respond_with_command_help(command_info_module)
+    end
+
+    def command_valid_args(command_info_module)
+      command_info_module.const_defined?('VALID_ARGS') ? command_info_module::VALID_ARGS : []
+    end
+
+    def command_description(command_info_module)
+      command_info_module.const_defined?('DESCRIPTION') ? command_info_module::DESCRIPTION : ''
+    end
+
+    # stdin is `conify help` or `conify -h`
+    def seeking_help?
+      @current_args.length == 0 && (@current_cmd.empty? || ['help', '--help', '-h'].include?(@current_cmd))
+    end
+
+    def respond_with_help
+      create_commands_map
+
+      header = [
+        'Usage: conify COMMAND [command-specific-arguments]',
+        'Type "conify COMMAND --help" for more details about each command',
+        'Commands:'
+      ].join("\n\n")
+
+      commands_info = usage_info(commands)
+
+      puts "\n#{header}"
+      puts "\n#{commands_info}\n\n"
+      exit(0)
+    end
+
+    # Create a commands map to respond to `conify help` with.
+    def create_commands_map
+      # Require all the ruby command files
+      command_file_paths.each do |file|
+        require file
+
+        # Get basename for the file without the extension
+        basename = get_basename_from_file(file)
+
+        # Camelcase the basename to be the klass name
+        klass_name = camelize(basename)
+
+        # return the command klass for this klass_name
+        command_klass = Conify::Command.const_get(klass_name)
+
+        # For each of the user-defined methods inside this class, create a command for it
+        manually_added_methods(command_klass).each { |method|
+          register_command(basename, method.to_s, command_klass, global: basename == 'global')
+        }
+      end
+    end
+
+    # Format a map of commands into help output format
+    def usage_info(map)
+      keys = map.keys
+      commands_column_width = keys.max_by(&:length).length + 1
+      commands_column_width += 2 if commands_column_width < 12
+
+      # iterate through each of the commands, create an array
+      # of strings in a `<command>  #  <description>` format. Sort
+      # them alphabetically, and then join them with new lines.
+      keys.map { |key|
+        command = "  #{key}"
+        command += (' ' * (commands_column_width - key.length + 1))
+        command += "#  #{map[key][:description]}"
+        command
+      }.sort_by{ |k| k.downcase }.join("\n")
+    end
+
+    # Seeking command-specific help. e.g. `conify bundles --help`
+    def seeking_command_help?(args)
+      args.include?('-h') || args.include?('--help')
+    end
+
+    # Respond to command-specific help
+    def respond_with_command_help(command_info_module)
+      help = "\nValid Command Formats:\n\n"
+
+      command_valid_args(command_info_module).each { |format|
+        help += "#  conify #{@current_cmd} #{format.join(' ')}\n"
+      }
+
+      puts "#{help}\n"
+    end
+
+    # stdin is `conify --version` or `conify -v`
+    def seeking_version?
+      @current_args.length == 0 && (@current_cmd == '--version' || @current_cmd == '-v')
+    end
+
+    def respond_with_version
+      display "conify #{Conify::VERSION}"
+      exit(0)
+    end
+
+    # Return just the basename for a file, no extensions.
+    def get_basename_from_file(file)
+      basename = Pathname.new(file).basename.to_s
+      basename[0..(basename.rindex('.') - 1)]
+    end
+
+    # Feturn an array of all command file paths, with the exception of abstract_command.rb
+    def command_file_paths
+      abstract_file = File.join(File.dirname(__FILE__), 'command', 'abstract_command.rb')
+      Dir[File.join(File.dirname(__FILE__), 'command', '*.rb')] - [abstract_file]
+    end
+
+    def commands
+      @@commands ||= {}
+    end
+
+    # register a command's info to the @@commands map - utilized when calling `conify help`
+    def register_command(basename, action, command_class, global: false)
+      command = global ? action : (action == 'index' ? basename : "#{basename}:#{action}")
+
+      command_info_module = command_class::CommandInfo.const_get(camelize(action))
+
+      commands[command] = { description: command_description(command_info_module) }
+    end
+
+  end
+end