cog-rb 0.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5858a013f657bf57c9dc372951d33d4f915ce73f
+  data.tar.gz: c7318d78922ad2f13da3899069f73b815c2d1904
+SHA512:
+  metadata.gz: 4bbb2620093d355de471842989e383b47c72e18fa02f3ae395d07cb856b956fdfe419864a6fc2eda95bb2be44e89beebd036db2b7f1eb6593d2e026b61fe47da
+  data.tar.gz: be7ee2c72c195907a2f7d9d2727f6f79fcf9b87cec35e70db0cd3f21b8c5a54087489fb458d6880c94929453445d579dadb3013b9152dce6c6f91bb24be02baf

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,3 @@
+This project is subject to the Operable Code of Conduct. See
+[CODE_OF_CONDUCT.md](https://github.com/operable/cog/blob/master/CODE_OF_CONDUCT.md) in the main
+[Cog](https://github.com/operable/cog) repo for more details.

data/CONTRIBUTING.MD

@@ -0,0 +1 @@
+For information about making contributions to this project please see [CONTRIBUTING.md](https://github.com/operable/cog/blob/master/CONTRIBUTING.md) in the main [Cog](https://github.com/operable/cog) repo.

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2015 Operable, Inc.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.

data/README.md

@@ -0,0 +1,45 @@
+# cog-rb
+
+Simple, opinionated library for building Cog commands in Ruby.
+
+## Usage
+
+First, create a file named `cog-command` at the top level of your project directory. This file should look something like the following, with `format` replaced with the name of your bundle:
+
+```ruby
+#!/usr/bin/env ruby
+
+# Make sure we're in the top-level directory for the command
+# since so many paths are relative.
+Dir.chdir(File.dirname(__FILE__))
+
+require 'bundler/setup'
+require 'cog'
+
+Cog.bundle('format')
+```
+
+This file will be the target `executable` for every command in your bundle. The library handles routing commands to the correct class based on the command name. Note: The permissions on this file must allow it to be run by your Relay.
+
+The class that implements your command should be named the same as your command and should be declared in a namespace named after your bundle within the `CogCmd` toplevel namespace. For instance, if you had a bundle named **test** and a command named **dump**, the class that implements the **dump** command would be called `CogCmd::Test::Dump`. The implementation for the command would live in `lib/cog_cmd/test/dump.rb` relative to the location of your `cog-command` script.
+
+## Examples
+
+See the [cog-bundles/format](https://github.com/cog-bundles/format) repository for an example of this library in action.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cog-rb'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cog-rb
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "cog/rb"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/cog-rb.gemspec

@@ -0,0 +1,21 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cog/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cog-rb"
+  spec.version       = Cog::VERSION
+  spec.authors       = ["Mark Imbriaco"]
+  spec.email         = ["mark@operable.io"]
+
+  spec.summary       = "Cog command helper library"
+  spec.homepage      = "https://github.com/cog-bundles/cog-rb"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+end

data/lib/cog/bundle.rb

@@ -0,0 +1,40 @@
+class Cog
+  class Bundle
+    attr_reader :name, :config
+
+    def initialize(name, base_dir: nil, config_file: nil)
+      @name = name
+      @base_dir = base_dir || File.dirname($0)
+      @config = load_config(config_file || File.join(@base_dir, 'config.yaml'))
+      @module = create_bundle_module
+
+      load_commands
+    end
+
+    def create_bundle_module
+      return if Object.const_defined?('CogCmd')
+
+      Object.const_set('CogCmd', Module.new)
+      CogCmd.const_set(@name.capitalize, Module.new)
+    end
+
+    def load_config(path=nil)
+      path ||= File.join(@base_dir, 'config.yaml')
+      Cog::Config.new(path)
+    end
+
+    def load_commands
+      @config[:commands].each do |command, config|
+        require File.join(@base_dir, 'lib', 'cog_cmd', @name, command)
+      end
+    end
+
+    def run_command
+      command = ENV['COG_COMMAND']
+      command_class = command.gsub(/(\A|_)([a-z])/) { $2.upcase }
+
+      target = @module.const_get(command_class).new
+      target.execute
+    end
+  end
+end

data/lib/cog/command.rb

@@ -0,0 +1,65 @@
+
+require 'json'
+
+class Cog
+  class Command
+    attr_writer :memory_key, :config
+
+    def request
+      @request ||= Cog::Request.new
+    end
+
+    def response
+      @response ||= Cog::Response.new
+    end
+
+    def memory_key
+      @memory_key ||= ENV['COG_INVOCATION_ID']
+    end
+
+    def config
+      @config ||= { input: self.class.input }
+    end
+
+    def step
+      step = ENV['COG_INVOCATION_STEP']
+      step.nil? ? nil : step.to_sym
+    end
+
+    def accumulate_input
+      Cog::Services::Memory.accum(memory_key, request.input)
+    end
+
+    def fetch_input
+      JSON.parse(Cog::Services::Memory.get(memory_key))
+    end
+
+    def execute
+      accumulate_input if config[:input] == :accumulate
+      run_command
+      response.send
+    end
+
+    def env_var(var, suffix: nil, required: false, failure_message: nil)
+      key = suffix ? "#{var}_#{suffix.upcase}" : var
+      value = ENV[key]
+
+      if required and value.nil?
+        message = failure_message ? failure_message : "Required environment variable #{key} missing!"
+        fail(message)
+      else
+        value
+      end
+    end
+
+    def fail(message)
+      STDERR.puts(message)
+      exit 1
+    end
+
+    def self.input(value=nil)
+      return @input if value.nil?
+      @input = value
+    end
+  end
+end

data/lib/cog/config.rb

@@ -0,0 +1,18 @@
+
+require "yaml"
+
+class Cog
+  class Config
+    def initialize(config_file)
+      @config = YAML.load(File.read(config_file))
+    end
+
+    def dump
+      YAML.dump(@config)
+    end
+
+    def [](key)
+      @config[key.to_s]
+    end
+  end
+end

data/lib/cog/request.rb

@@ -0,0 +1,27 @@
+
+require 'json'
+
+class Cog
+  class Request
+    attr_reader :options, :args, :input
+
+    def initialize
+      @args = populate_args
+      @options = populate_options
+      @input = JSON.parse(STDIN.read)
+    end
+
+    private
+
+    def populate_args
+      (0 .. (ENV['COG_ARGC'].to_i - 1)).map { |n| ENV["COG_ARGV_#{n}"] }
+    end
+
+    def populate_options
+      return {} if ENV['COG_OPTS'].nil?
+
+      options = ENV["COG_OPTS"].split(",")
+      Hash[options.map { |opt| [ opt, ENV["COG_OPT_#{opt.upcase}"] ]}]
+    end
+  end
+end

data/lib/cog/response.rb

@@ -0,0 +1,48 @@
+
+require 'json'
+
+class Cog
+  class Response
+    LOG_LEVELS = [ :debug, :info, :warn, :err, :error ]
+
+    attr_accessor :template, :content
+
+    def []=(key, value)
+      @content ||= {}
+      @content[key] = value
+    end
+
+    def send
+      return if content.nil?
+
+      write "COG_TEMPLATE: #{@template}" unless @template.nil?
+
+      case content.class
+      when String
+        write @content.join('').to_json
+      else
+        write "JSON\n" + @content.to_json
+      end
+    end
+
+    def write(message)
+      self.class.write(message)
+    end
+
+    def log(level, message)
+      self.class.log(level, message)
+    end
+
+    class << self
+      def write(message)
+        puts message
+        STDOUT.flush
+      end
+
+      def log(level, message)
+        level = LOG_LEVELS.include?(level) ? level : :info
+        write "COGCMD_#{level.to_s.upcase}: #{message}"
+      end
+    end
+  end
+end

data/lib/cog/service.rb

@@ -0,0 +1,70 @@
+
+require 'net/http'
+
+class Cog
+  class Service
+    class << self
+      def headers
+        {
+          "Authorization" => "pipeline #{ENV['COG_SERVICE_TOKEN']}",
+          "Content-Type"  => "application/json"
+        }
+      end
+
+      def uri_for(path=nil)
+        service_path =
+          if path.class == URI::HTTP
+            path
+          else
+            [ service_name, version, path ].compact.join('/')
+          end
+
+        URI(ENV['COG_SERVICES_ROOT'] + '/v1/services/' + service_path)
+      end
+
+      def service_name
+        get_const('SERVICE_NAME', self.to_s.split('::').last.downcase)
+      end
+
+      def version
+        get_const('VERSION')
+      end
+
+      def get(path=nil)
+        uri = uri_for(path)
+        res = Net::HTTP.start(uri.host, uri.port) do |http|
+          req = Net::HTTP::Get.new(uri)
+          headers.each { |k,v| req[k] = v }
+          http.request(req)
+        end
+
+        res.body
+      end
+
+      def post(path: nil, data: nil)
+        put_or_post(:post, path: path, data: data)
+      end
+
+      def put(path: nil, data: nil)
+        put_or_post(:put, path: path, data: data)
+      end
+
+      private
+
+      def get_const(name, default=nil)
+        self.const_defined?(name) ? self.const_get(name) : default
+      end
+
+      def put_or_post(type, path: nil, data: nil)
+        uri = uri_for(path)
+        http_class = (type == :post) ? Net::HTTP::Post : Net::HTTP::Put
+        req = http_class.new(uri, headers)
+        req.body = data
+
+        res = Net::HTTP.start(uri.host, uri.port) do |http|
+          http.request(req)
+        end
+      end
+    end
+  end
+end

data/lib/cog/services/memory.rb

@@ -0,0 +1,17 @@
+class Cog
+  class Services
+    class Memory < Cog::Service
+      VERSION = "1.0.0"
+
+      class << self
+        def accum(key, value)
+          post(path: key, data: { "op" => "accum", "value" => value }.to_json)
+        end
+
+        def replace(key, value)
+          put(path: key, data: value.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/cog/services/metadata.rb

@@ -0,0 +1,7 @@
+class Cog
+  class Services
+    class Metadata < Cog::Service
+      SERVICE_NAME = :meta
+    end
+  end
+end

data/lib/cog/version.rb

@@ -0,0 +1,3 @@
+class Cog
+  VERSION = "0.1.5"
+end

data/lib/cog.rb

@@ -0,0 +1,19 @@
+
+require_relative 'cog/bundle'
+require_relative 'cog/config'
+require_relative 'cog/command'
+require_relative 'cog/request'
+require_relative 'cog/response'
+require_relative 'cog/version'
+
+require_relative 'cog/service'
+require_relative 'cog/services/memory'
+require_relative 'cog/services/metadata'
+
+class Cog
+  def self.bundle(name)
+    bundle = Cog::Bundle.new(name)
+    yield bundle if block_given?
+    bundle.run_command
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: cog-rb
+version: !ruby/object:Gem::Version
+  version: 0.1.5
+platform: ruby
+authors:
+- Mark Imbriaco
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+description: 
+email:
+- mark@operable.io
+executables:
+- console
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CODE_OF_CONDUCT.md
+- CONTRIBUTING.MD
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- cog-rb.gemspec
+- lib/cog.rb
+- lib/cog/bundle.rb
+- lib/cog/command.rb
+- lib/cog/config.rb
+- lib/cog/request.rb
+- lib/cog/response.rb
+- lib/cog/service.rb
+- lib/cog/services/memory.rb
+- lib/cog/services/metadata.rb
+- lib/cog/version.rb
+homepage: https://github.com/cog-bundles/cog-rb
+licenses: []
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: Cog command helper library
+test_files: []