perkins 0.0.1

data/lib/perkins/build/script.rb

@@ -0,0 +1,167 @@
+require 'core_ext/hash/deep_merge'
+require 'core_ext/hash/deep_symbolize_keys'
+require 'core_ext/object/false'
+require 'erb'
+
+module Perkins
+  module Build
+    class Script
+      autoload :Helpers, 'perkins/build/script/helpers'
+
+      #autoload :Stages,  'perkins/build/script/stages'
+      #autoload :Ruby,    'perkins/build/script/ruby'
+      #autoload :Go,      'perkins/build/script/go'
+
+      #autoload :Addons,         'perkins/build/script/addons'
+      #autoload :Android,        'perkins/build/script/android'
+      autoload :Bundler,        'perkins/build/script/bundler'
+      #autoload :C,              'perkins/build/script/c'
+      #autoload :Cpp,            'perkins/build/script/cpp'
+      #autoload :Clojure,        'perkins/build/script/clojure'
+      #autoload :DirectoryCache, 'perkins/build/script/directory_cache'
+      #autoload :Erlang,         'perkins/build/script/erlang'
+      #autoload :Git,            'perkins/build/script/git'
+      autoload :Go,             'perkins/build/script/go'
+      #autoload :Groovy,         'perkins/build/script/groovy'
+      #autoload :Generic,        'perkins/build/script/generic'
+      #autoload :Haskell,        'perkins/build/script/haskell'
+      autoload :Helpers,        'perkins/build/script/helpers'
+      autoload :Jdk,            'perkins/build/script/jdk'
+      #autoload :Jvm,            'perkins/build/script/jvm'
+      #autoload :NodeJs,         'perkins/build/script/node_js'
+      #autoload :ObjectiveC,     'perkins/build/script/objective_c'
+      #autoload :Perl,           'perkins/build/script/perl'
+      #autoload :Php,            'perkins/build/script/php'
+      #autoload :PureJava,       'perkins/build/script/pure_java'
+      #autoload :Python,         'perkins/build/script/python'
+      autoload :Ruby,           'perkins/build/script/ruby'
+      #autoload :Rust,           'perkins/build/script/rust'
+      autoload :RVM,            'perkins/build/script/rvm'
+      #autoload :Scala,          'perkins/build/script/scala'
+      autoload :Services,       'perkins/build/script/services'
+      autoload :Stages,         'perkins/build/script/stages'
+
+      TEMPLATES_PATH = File.expand_path('../script/templates', __FILE__)
+
+      STAGES = {
+        builtin: [:configure, :checkout, :pre_setup, :export, :setup, :announce],
+        custom:  [:before_install, :install, :before_script, :script, :after_result, :after_script]
+      }
+
+      attr_reader :stack, :repo, :config
+      attr_reader :data, :options
+
+      class << self
+        def defaults
+          self::DEFAULTS
+        end
+      end
+
+
+      include Helpers, Stages
+
+      def initialize(data, repo)
+        @config = data #used in runner
+        @repo = repo
+        #@stack = []
+        @data = Data.new({ config: self.class.defaults }.deep_merge(data.deep_symbolize_keys))
+        @options = options
+        @stack = [Shell::Script.new(echo: true, timing: true)]
+      end
+
+      #run stages
+      def compile
+        #run_stages if check_config
+        #@stack.compact.join(" && ")
+        raw template 'header.sh'
+        run_stages.compact if check_config
+        raw template 'footer.sh'
+        sh.to_s
+      end
+
+      private
+
+      def check_config
+        case data.config.present? #[:".result"]
+        when 'not_found'
+          echo 'Could not find .travis.yml, using standard configuration.', ansi: :red
+          true
+        when 'server_error'
+          echo 'Could not fetch .travis.yml from GitHub.', ansi: :red
+          raw 'travis_terminate 2'
+          false
+        else
+          true
+        end
+      end
+
+      def config
+        data.config
+      end
+
+      def export
+=begin
+        set 'TRAVIS', 'true', echo: false
+        set 'CI', 'true', echo: false
+        set 'CONTINUOUS_INTEGRATION', 'true', echo: false
+        set 'HAS_JOSH_K_SEAL_OF_APPROVAL', 'true', echo: false
+
+        newline if data.env_vars_groups.any?(&:announce?)
+
+        data.env_vars_groups.each do |group|
+          echo "Setting environment variables from #{group.source}", ansi: :yellow if group.announce?
+          group.vars.each { |var| set var.key, var.value, echo: var.to_s }
+        end
+
+        newline if data.env_vars_groups.any?(&:announce?)
+=end
+      end
+
+      def finish
+        puts "finish"
+        #"push_directory_cache"
+      end
+
+      def pre_setup
+        puts "pre setup"
+        #start_services
+        #setup_apt_cache if data.cache? :apt
+        #fix_ps4
+        #run_addons(:after_pre_setup)
+      end
+
+      def setup
+        puts "setup"
+        #setup_directory_cache
+      end
+
+      def announce
+        # overwrite
+      end
+
+      def configure
+        #fix_resolv_conf
+        #fix_etc_hosts
+      end
+
+      #instance git repo
+      def checkout
+        @repo.load_git
+        nil
+      end
+
+      STAGES[:custom].each do |meth|
+       define_method(meth) do
+          puts "performing default #{meth}"
+        end
+      end
+
+      def template(filename)
+        @working_dir = @repo.working_dir + @repo.name
+        ERB.new(File.read(File.expand_path(filename, TEMPLATES_PATH))).result(binding)
+      end
+
+    end
+
+  end
+end

data/lib/perkins/build/shell/dsl.rb

@@ -0,0 +1,104 @@
+module Perkins
+  module Build
+    module Shell
+      module Dsl
+        def script(*args, &block)
+          nodes << Script.new(*merge_options(args), &block)
+          nodes.last
+        end
+
+        def cmd(code, *args)
+          options = args.last.is_a?(Hash) ? args.last : {}
+          node = Cmd.new(code, *merge_options(args))
+          options[:fold] ? fold(options[:fold]) { raw(node) } : raw(node)
+        end
+
+        def raw(code, *args)
+          args = merge_options(args)
+          pos = args.last.delete(:pos) || -1
+          node = code.is_a?(Node) ? code : Node.new(code, *args)
+          nodes.insert(pos, node)
+        end
+
+        def export(name, value, options = {})
+          cmd "export #{name}=#{value}", { assert: false, timing: false }.merge(options)
+        end
+
+        def set(name, value, options = {})
+          cmd "export #{name}=#{value}", { assert: false, timing: false }.merge(options)
+        end
+        #alias set export
+
+        def echo(string, options = {})
+          string = ansi(string, options) if options[:ansi]
+          cmd "echo -e #{escape(string)}", { assert: false, echo: false, timing: false }.merge(options)
+        end
+
+        def newline
+          raw 'echo'
+        end
+
+        def cd(path)
+          cmd "cd #{path}", echo: true, timing: false
+        end
+
+        def file(path, content)
+          raw "echo #{escape(content)} > #{path}"
+        end
+
+        def if(*args, &block)
+          args = merge_options(args)
+          els_ = args.last.delete(:else)
+          nodes << If.new(*args, &block)
+          self.else(els_, args.last) if els_
+          nodes.last
+        end
+
+        def elif(*args, &block)
+          raise InvalidParent.new(Elif, If, nodes.last.class) unless nodes.last.is_a?(If)
+          args = merge_options(args)
+          els_ = args.last.delete(:else)
+          nodes.last.raw Elif.new(*args, &block)
+          self.else(els_, args.last) if els_
+          nodes.last
+        end
+
+        def else(*args, &block)
+          raise InvalidParent.new(Else, If, nodes.last.class) unless nodes.last.is_a?(If)
+          nodes.last.raw Else.new(*merge_options(args), &block)
+          nodes.last
+        end
+
+        def fold(name, &block)
+          raw "travis_fold start #{name}"
+          result = yield(self)
+          raw "travis_fold end #{name}"
+          result
+        end
+
+        private
+
+          def merge_options(args, options = {})
+            options = (args.last.is_a?(Hash) ? args.pop : {}).merge(options)
+            args << self.options.merge(options)
+          end
+
+          ANSI = {
+            green:  '\033[32;1m',
+            red:    '\033[31;1m',
+            yellow: '\033[33;1m',
+            reset:  '\033[0m'
+          }
+
+          def ansi(string, options)
+            keys = Array(options[:ansi])
+            prefix = keys.map { |key| ANSI[key] }
+            lines = string.split("\n").map do |line|
+              line.strip.empty? ? line : [prefix, line, ANSI[:reset]].flatten.join
+            end
+            lines.join("\n")
+          end
+      end
+    end
+  end
+end

data/lib/perkins/build/shell/node.rb

@@ -0,0 +1,121 @@
+require 'shellwords'
+require 'core_ext/string/indent'
+
+module Perkins
+  module Build
+    module Shell
+      class Node
+        attr_reader :code, :options, :level
+
+        def initialize(*args)
+          @options = args.last.is_a?(Hash) ? args.pop : {}
+          @level = options.delete(:level) || 0
+          @code = args.first
+          yield(self) if block_given?
+        end
+
+        def name
+          self.class.name.split('::').last.downcase
+        end
+
+        def to_s
+          code ? code.indent(level) : code
+        end
+
+        def escape(code)
+          Shellwords.escape(code)
+        end
+      end
+
+      class Cmd < Node
+        def code
+          if opts.any?
+            ['travis_cmd', escape(super), *opts].join(' ')
+          else
+            super
+          end
+        end
+
+        def opts
+          opts ||= []
+          opts << '--assert' if options[:assert]
+          opts << '--echo'   if options[:echo]
+          opts << '--retry'  if options[:retry]
+          opts << '--timing' if options[:timing]
+          opts << "--display #{escape(options[:echo])}" if options[:echo].is_a?(String)
+          opts
+        end
+      end
+
+      class Group < Node
+        include Dsl
+
+        attr_reader :nodes
+
+        def initialize(*args, &block)
+          @options = args.last.is_a?(Hash) ? args.pop : {}
+          @level = options.delete(:level) || 0
+          @nodes = []
+          args.map { |node| cmd(node, options) }
+          yield(self) if block_given?
+        end
+
+        def to_s
+          nodes.map(&:to_s).join("\n").indent(level)
+        end
+      end
+
+      class Script < Group
+        def to_s
+          super + "\n"
+        end
+      end
+
+      class Block < Group
+        attr_reader :open, :close
+
+        def to_s
+          [open, super, close].compact.join("\n")
+        end
+
+        def script(*args)
+          super(*merge_options(args, level: 1))
+        end
+
+        def cmd(code, *args)
+          super(code, *merge_options(args, level: 1))
+        end
+
+        def raw(code, *args)
+          super(code, *merge_options(args, level: 1))
+        end
+      end
+
+      class Conditional < Block
+        def initialize(condition, *args, &block)
+          args.unshift(args.last.delete(:then)) if args.last.is_a?(Hash) && args.last[:then]
+          unless args.last.delete(:raw_condition)
+            condition = "[[ #{condition} ]]"
+          end
+          super(*args, &block)
+          @open = Node.new("#{name} #{condition}; then", options)
+        end
+      end
+
+      class If < Conditional
+        def close
+          Node.new('fi', options)
+        end
+      end
+
+      class Elif < Conditional
+      end
+
+      class Else < Block
+        def open
+          @open = Node.new('else', options)
+        end
+      end
+    end
+  end
+end

data/lib/perkins/build/shell.rb

@@ -0,0 +1,16 @@
+module Perkins
+  module Build
+    module Shell
+      autoload :Dsl,     'perkins/build/shell/dsl'
+      autoload :Node,    'perkins/build/shell/node'
+      autoload :Cmd,     'perkins/build/shell/node'
+      autoload :Script,  'perkins/build/shell/node'
+
+      class InvalidParent < RuntimeError
+        def initialize(node, required, actual)
+          super("Node #{node.name} requires to be added to a #{required.name}, but is a #{actual.name}")
+        end
+      end
+    end
+  end
+end

data/lib/perkins/build.rb

@@ -0,0 +1,27 @@
+module Perkins
+  module Build
+    autoload :Data,     'perkins/build/data'
+    autoload :Script,   'perkins/build/script'
+    #autoload :Services, 'perkins/build/services'
+    autoload :Shell,    'perkins/build/shell'
+
+    HOME_DIR  = '$HOME'
+    BUILD_DIR = File.join(HOME_DIR, 'build')
+
+    class << self
+
+      def script(config, options = {})
+        #config  = config.deep_symbolize_keys
+        lang  = (config.language || 'ruby').downcase.strip
+        const = by_lang(lang)
+        const.new(config, options)
+      end
+
+      def by_lang(lang)
+        name = lang.split('_').map { |w| w.capitalize }.join
+        Script.const_get(name, false) rescue Script::Ruby
+      end
+
+    end
+  end
+end

data/lib/perkins/build_report.rb

@@ -0,0 +1,11 @@
+module Perkins
+  class BuildReport < ActiveRecord::Base
+    belongs_to :repo
+
+    def commit
+      self.repo.load_git
+      @commit ||= Perkins::Commit.new(self.sha, self.repo)
+    end
+
+  end
+end

data/lib/perkins/cli.rb

@@ -0,0 +1,42 @@
+require "thor"
+require "thor/group"
+require "pry"
+#require "debugger"
+module Perkins
+  class CLI < Thor
+    include Thor::Actions
+    include Perkins::ThorUtils
+
+    STATUS_TYPES = {:success          => 0,
+                    :general_error    => 1,
+                    :not_supported    => 3,
+                    :not_found        => 4,
+                    :incorrect_usage  => 64,
+                    }
+
+    no_commands {
+      def cli_error(message, exit_status=nil)
+        $stderr.puts message
+        exit_status = STATUS_TYPES[exit_status] if exit_status.is_a?(Symbol)
+        exit(exit_status || 1)
+      end
+    }
+
+    ### TODO: When these commands list grows big, we need to move them into a seperate commands.rb file
+    map %w(--version -v) => 'info'
+    desc "info", "information about Perkins::Client::Generator."
+    def info
+      say "Version #{::Perkins::VERSION}"
+    end
+
+    map %w(s) => 'server'
+    desc "server ", "run Perkins app"
+    method_option :host, :default => "localhost"
+    method_option :port, :default => 9292
+    method_option :e, :default => "development"
+    def server(config)
+      ::Perkins::Server.start(config, options)
+    end
+
+  end
+end

data/lib/perkins/commit.rb

@@ -0,0 +1,30 @@
+module Perkins
+  class Commit
+
+    attr_reader :sha, :author, :created_at, :message
+    attr_accessor :branch
+
+    def initialize(sha,  repo)
+      return if sha.nil?
+      @commit = repo.git.gcommit(sha)
+      @sha = sha
+    end
+
+    def author
+      @commit.author.name unless @commit.blank?
+    end
+
+    def email
+      @commit.author.email unless @commit.blank?
+    end
+
+    def created_at
+      @commit.author.date unless @commit.blank?
+    end
+
+    def message
+      @commit.message unless @commit.blank?
+    end
+
+  end
+end

data/lib/perkins/dsl/app_proxy.rb

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+module Perkins
+  class AppProxy
+    APP_ATTRIBUTES = [:host, :port, :redis, :github_client_secret, :github_client_id ]
+
+    attr_accessor *APP_ATTRIBUTES
+    attr_reader :app
+
+    def initialize(options)
+      @app = Application.new(options)
+    end
+
+    def server=(opts={})
+      opts.each{|k,v| Server.set(k,v)}
+      Server.set(:app , @app)
+    end
+
+    def config(&block)
+      @app.instance_eval &block
+    end
+
+  end
+end

data/lib/perkins/dsl.rb

@@ -0,0 +1,12 @@
+# -*- encoding: utf-8 -*-
+module Perkins
+  def self.application(options = {}, &block)
+    app_proxy = Perkins::AppProxy.new(options)
+    if block.arity == 0
+      app_proxy.instance_eval &block
+    else
+      app_proxy.instance_exec(app_proxy, &block)
+    end
+    app_proxy.app
+  end
+end

data/lib/perkins/listener.rb

@@ -0,0 +1,38 @@
+
+module Perkins
+
+  #this should be a daemon
+  #it will listen incoming messages
+  #it will run the propper repo with runner commands
+  #it will pass the message to other daemon to notify
+  #it will deploy ?
+
+  class Listener
+
+    attr_accessor :app
+
+    def run!
+      #chan't use the same $redis conn because it fails
+      #TODO: reconnect with same settings
+      redis_conn = Redis.new()
+      redis_conn.subscribe('perkins:commits') do |on|
+        on.message do |channel, msg|
+          exec_runner(channel, msg)
+        end
+      end
+    end
+
+    def exec_runner(channel, msg)
+      data = JSON.parse(msg)
+      puts "##{channel} - [#{data['name']}]: #{data['sha']}"
+
+      repo = Perkins::Repo.find(data["id"])
+
+      #Thread.new do
+        Worker.perform(repo, data['sha'], data['branch'] )
+      #end
+    end
+
+  end
+
+end

data/lib/perkins/logger.rb

@@ -0,0 +1,12 @@
+module Perkins
+  class Logger
+
+    def self.report(msg)
+      $stdout.puts(msg.green.bold)
+    end
+
+    def self.error(msg)
+      $stderr.puts(msg.red.bold)
+    end
+  end
+end

data/lib/perkins/notifier.rb

@@ -0,0 +1,5 @@
+
+module Perkins
+  class Notifier
+  end
+end