kata 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 799c980fa1d662dff11f1fe752746b0df6c25def
-  data.tar.gz: d3aa26a5a75c4c38b3319159b4ec801bde30b125
+  metadata.gz: 9f38d529f6814fb12f472bb2bfa479f7a00a334d
+  data.tar.gz: 2bd597620a28cc985ce3ce8e18215d193e3e1339
 SHA512:
-  metadata.gz: 6974b2ece4c3aac1df67a5165382d65c6b821398834e2652dc11d492bfc56ccdc0408a44b1b1044165a301698ba362a54addb82a86bb583e7c3c6079a1d51166
-  data.tar.gz: b99833cf31190965749febe5ae27a2450ab6f02367ff3cd3fcb3dc79fc9fa362506806e1ca74c75aa5a59c02d7520371cf8f8575c831b4d89c454f22b614c1ac
+  metadata.gz: ea74244753c10614fce17195944dd29a75db466c4a0eb57362ce2e4635bed0e74e8ef51529a021ae6a79489d7ae6a30a6729f810ee45d34ff6e047ae2b26f635
+  data.tar.gz: b5513df5b97f52c2e9f71ade69caba49137845cae21242c0d9a999fdc667854e5d330af8eca1008f4deb378f4a74c565e7c89804d6f7a1a2301c14cf44c4b052

data/bin/kata

@@ -21,6 +21,7 @@ PRIMARY COMMANDS
 
         --no-repo         - Add the directory tree and files to the current repo if possible
         --language=option - Define the programming language for the directory tree that is built
+                            VALID OPTIONS [ruby,node,php]
         file              - Path to the code kata source file for the practice session
 
     kata take file
@@ -48,7 +49,7 @@ OptionParser.new do |opts|
     options.repo = false
   end
 
-  opts.on('-l[OPTIONAL]', '--language[=OPTIONAL]', 'Setup the kata file tree using the specified language') do |lang|
+  opts.on('-l', '--language [LANG]', 'Setup the kata file tree using the specified language') do |lang|
     options.language = lang
   end
 end.parse!
@@ -64,6 +65,7 @@ options.file = ARGV.shift
 case options.action
   when :setup
     raise(ArgumentError, 'No kata source file specified') unless options.file && File.exists?(options.file)
+    raise(ArgumentError, 'Invalid language option') unless %w{ruby node php}.include?(options.language)
 
     name = nil
 

data/lib/kata.rb

@@ -1,5 +1,6 @@
 require 'kata/setup/base'
 require 'kata/setup/ruby'
-require 'kata/setup/javascript'
+require 'kata/setup/node'
+require 'kata/setup/php'
 require 'kata/base'
 require 'kata/version'

data/lib/kata/base.rb

@@ -66,13 +66,16 @@ module Kata
     def complete(status = true)
       return if @@times.size == 0
 
-      formatter = lambda do |sec|
-        use = sec.round
-        [use/3600, use/60 % 60, use % 60].map {|v| v.to_s.rjust(2,'0')}.join(':')
-      end
-
       suppress_output
+      report
+      content = capture_output
+
+      File.open('report.txt', 'w').write(content)
+
+      puts content
+    end
 
+    def report
       table :border => true do
         row :header => true do
           column 'Requirement', :color => 'red', :width => 80
@@ -82,16 +85,15 @@ module Kata
         @@times.each do |t|
           row do
             column t[:title]
-            column formatter.call(t[:time])
+            column format_time(t[:time])
           end
         end
       end
+    end
 
-      report = capture_output
-
-      File.open('report.txt', 'w').write( report )
-
-      puts report
+    def format_time(sec)
+      use = sec.round
+      [use/3600, use/60 % 60, use % 60].map {|v| v.to_s.rjust(2,'0')}.join(':')
     end
 
     def ancestry

data/lib/kata/setup/base.rb

@@ -28,13 +28,21 @@ module Kata
         case type
         when 'ruby'
           Kata::Setup::Ruby.new(kata_name).build_tree
-        when 'javascript'
-          Kata::Setup::Javascript.new(kata_name).build_tree
+        when 'node'
+          Kata::Setup::Node.new(kata_name).build_tree
+        when 'php'
+          Kata::Setup::Php.new(kata_name).build_tree
+        else
+          raise(ArgumentError, "Invalid language type #{type}")
         end
       end
 
       private
 
+      def tree(path)
+        FileUtils.mkdir_p(File.join(repo_name, path))
+      end
+
       def use_kata_name
         kata_name.gsub(/( |-)\1?/, '_').downcase
       end
@@ -43,8 +51,15 @@ module Kata
         kata_name.split(/ |-|_/).map(&:capitalize).join
       end
 
+      def write_repo_file(use_file, use_contents, permissions = 0644)
+        File.open(File.join(repo_name, use_file), 'w') do |f|
+          f.write(use_contents)
+          f.chmod(permissions) rescue Exception
+        end
+      end
+
       def readme
-        File.open(File.join(repo_name, 'README'), 'w') { |f| f.write(<<EOF) }
+        write_repo_file('README',<<EOF)
 Leveling up my coding awesomeness!
 EOF
       end
@@ -55,28 +70,46 @@ EOF
 
         @github ||=
           begin
-            tmp = OpenStruct.new
+            struct = OpenStruct.new
+
+            struct.token = %x{git config --get github.token}.chomp
 
             github_user = %x{git config --get github.user}.chomp
             shell_user = ENV['USER']
 
-            tmp.user = github_user.empty? ? shell_user : github_user
+            struct.user = github_user.empty? ? shell_user : github_user
 
-            raise Exception, 'Unable to determine github user' if tmp.user.empty?
+            struct
+          end
+      end
 
-            print 'Github account password: '
-            tmp.password = STDIN.noecho(&:gets).chomp
+      def client_factory
+        if github.token
+          # nothing to do
+        elsif github.user
+          get_password
+          get_token
+        else
+          raise Exception, 'Unable to determine github.token or github.user' if github.user.empty?
+        end
 
-            tmp
-          end
+        client.access_token = github.token
       end
 
       def client
-        @client ||= Octokit::Client.new(:login => github.user, :password => github.password)
+        @client ||= Octokit::Client.new
+      end
+
+      def get_password
+        print 'Github account password: '
+        github.password = STDIN.noecho(&:gets).chomp
       end
 
-      def create_session_token
-        authorization = client.create_authorization({:scopes => ['public_repo'], :note => 'Ruby Kata'})
+      def get_token
+        client.login = github.user
+        client.password = github.password
+
+        authorization = client.create_authorization({:scopes => ['public_repo'], :note => 'Code Kata'})
 
         github.token = authorization.token
 
@@ -85,29 +118,34 @@ EOF
       end
 
       def create_remote_repo
-        create_session_token
-
-        puts "Creating remote repo..."
-        client.create_repo "#{repo_name}"
-        puts "end"
+        client_factory
+
+        begin
+          print "Creating remote repo..."
+          client.create_repo "#{repo_name}"
+        rescue Exception
+          puts "\nError: unable to create the git repo."
+          print 'Proceeding...'
+        ensure
+          puts "done"
+        end
       end
 
       def push_local_repo(new_repo)
-        print "creating files for repo and initializing..."
-
         cmd = "cd #{repo_name} &&"
 
         if new_repo
-          cmd << "git init >/dev/null 2>&1 &&"
-          cmd << "git add README .rspec lib/ spec/ >/dev/null 2>&1 &&"
+          cmd << "git init &&"
+          #cmd << "git add README .rspec lib/ spec/ &&"
+          cmd << "git add . &&"
         else
-          cmd << "git add #{ENV['PWD']}/#{repo_name} >/dev/null 2>&1;"
+          cmd << "git add #{ENV['PWD']}/#{repo_name};"
         end
 
-        cmd << "git commit -m 'starting kata' > /dev/null 2>&1;"
+        cmd << "git commit -m 'starting kata';"
 
         if new_repo
-          cmd << "git remote add origin git@github.com:#{github.user}/#{repo_name}.git >/dev/null 2>&1 &&"
+          cmd << "git remote add origin git@github.com:#{github.user}/#{repo_name}.git &&"
         end
 
         cmd << 'git push origin master'

data/lib/kata/setup/{javascript.rb → node.rb}

@@ -2,31 +2,21 @@ require 'kata/setup/base'
 
 module Kata
   module Setup
-    class Javascript < Kata::Setup::Base
+    class Node < Kata::Setup::Base
       def build_tree
         %w{lib spec}.each { |path| tree(path) }
         readme
         package_json
-        base_class
+        autotest
+        kata_file
         kata_spec
       end
 
       private
 
-      def tree(path)
-        full_path = case path
-          when "lib"
-            File.join(repo_name, 'lib')
-          when "spec"
-            File.join(repo_name, "spec")
-          end
-
-        FileUtils.mkdir_p(full_path)
-      end
-
       # Using here docs for a cheap templating system
       def package_json
-        File.open(File.join(repo_name, 'package.json'), 'w') { |f| f.write(<<EOF) }
+        write_repo_file('package.json',<<EOF)
 {
   "name": "#{use_kata_name}",
   "version": "0.0.1",
@@ -38,9 +28,13 @@ module Kata
 EOF
       end
 
-      def base_class
+      def autotest
+        write_repo_file('autotest',"./node_modules/jasmine-node/bin/jasmine-node --autotest --color spec/", 0755)
+      end
+
+      def kata_file
         # create the base class file
-        File.open(File.join(repo_name, 'lib', "#{use_kata_name}.js"), 'w') {|f| f.write <<EOF}
+        write_repo_file(File.join('lib', "#{use_kata_name}.js"),<<EOF)
 var expression = null;
 
 exports.getExpr = function() { 
@@ -50,7 +44,7 @@ EOF
       end
 
       def kata_spec
-        File.open(File.join(repo_name, 'spec', "#{use_kata_name}_spec.js"), 'w') {|f| f.write <<EOF}
+        write_repo_file(File.join('spec', "#{use_kata_name}_spec.js"),<<EOF)
 var #{use_kata_name} = require("../lib/#{use_kata_name}");
 
 describe("#{class_name}", function() {

data/lib/kata/setup/php.rb

@@ -0,0 +1,87 @@
+require 'kata/setup/base'
+
+module Kata
+  module Setup
+    class Php < Kata::Setup::Base
+      def build_tree
+        %w{src test}.each { |path| tree(path) }
+        readme
+        bootstrap
+        composer_json
+        base_class
+        php_test
+      end
+
+      private
+
+      # Using here docs for a cheap templating system
+      def bootstrap
+        write_repo_file('bootstrap.h',<<EOF)
+#!/bin/sh
+
+php_version=$(php -v | head -1 | awk '{print $2}'  | sed 's/\\.//g')
+composer_version=5320
+
+if [[ $php_version -gt $composer_version ]]; then
+  curl -sS https://getcomposer.org/installer | php
+  mv composer.phar composer
+  chmod 755 composer
+  ./composer install
+  export PATH=vendor/bin:$PATH
+else
+  curl -O https://phar.phpunit.de/phpunit.phar
+  mv phpunit.phar phpunit
+  chmod 755 phpunit
+fi
+EOF
+      end
+
+      def composer_json
+        write_repo_file('composer.json',<<EOF)
+{
+    "require-dev": {
+        "phpunit/phpunit": "4.1.*"
+    }
+}
+EOF
+      end
+
+      def base_class
+        write_repo_file(File.join('src', "#{class_name}.php"),<<EOF)
+<?php
+
+class #{class_name} {
+
+  public function __construct() { }
+
+}
+
+?>
+EOF
+      end
+
+      def php_test
+        write_repo_file(File.join('test', "#{class_name}Test.php"),<<EOF)
+<?php
+
+require 'src/#{class_name}.php';
+
+class #{class_name}Test extends PHPUnit_Framework_TestCase {
+
+  public function testInstatiate#{class_name}() {
+    try {
+      $calc = new #{class_name}();
+    } catch (Exception $e) {
+      $this->fail();
+    }
+  }
+
+}
+
+?>
+EOF
+      end
+    end
+  end
+end
+

data/lib/kata/setup/ruby.rb

@@ -4,30 +4,43 @@ module Kata
   module Setup
     class Ruby < Kata::Setup::Base
       def build_tree
-        %w{lib spec helpers matchers}.each { |path| tree(path) }
+        %w{lib spec}.each { |path| tree(path) }
         readme
+        bootstrap
+        gemfile
         base_class
-        dot_rspec
-        spec_helper
+        dot_files
         kata_spec
-        spec_matcher
       end
 
       private
 
-      def tree(path)
-        full_path = case path
-          when "lib"
-            File.join(repo_name, 'lib')
-          when "spec"
-            File.join(repo_name, "spec")
-          when "matchers"
-            File.join(repo_name, "spec", "support", "matchers")
-          when "helpers"
-            File.join(repo_name, "spec", "support", "helpers")
-          end
+      def bootstrap
+        write_repo_file('bootstrap.sh',<<EOF)
+#!/bin/bash
+gem install bundler
+bundle install
+EOF
+      end
+
+      def gemfile
+        write_repo_file('Gemfile',<<EOF)
+source 'http://rubygems.org'
 
-        FileUtils.mkdir_p(full_path)
+gem 'kata'
+
+group :test do
+  gem 'rspec'
+  gem 'autotest'
+  gem 'autotest-growl'
+  gem 'rspec-autotest'
+end
+
+group :development do
+  gem 'debugger'
+  gem 'pry'
+end
+EOF
       end
 
       # Using here docs for a cheap templating system
@@ -39,25 +52,18 @@ end
 EOF
       end
 
-      def dot_rspec
-        File.open(File.join(repo_name, '.rspec'), 'w') {|f| f.write <<EOF}
---color --format d
-EOF
-      end
-
-      def spec_helper
-        File.open(File.join(repo_name, 'spec', 'spec_helper.rb'), 'w') {|f| f.write <<EOF}
-$: << '.' << File.join(File.dirname(__FILE__), '..', 'lib')
-
-require 'rspec'
-
-Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
+      def dot_files
+        write_repo_file('.rspec', '--color --format d')
+        write_repo_file('.ruby-version', 'ruby-2.0.0-p481')
+        write_repo_file('.ruby-gemset', "kata-#{use_kata_name}")
+        write_repo_file('.autotest', <<EOF)
+require 'autotest'
+require 'autotest-growl'
 EOF
       end
 
       def kata_spec
         File.open(File.join(repo_name, 'spec', "#{use_kata_name}_spec.rb"), 'w') {|f| f.write <<EOF}
-require 'spec_helper'
 require '#{use_kata_name}'
 
 describe #{class_name} do
@@ -69,16 +75,6 @@ describe #{class_name} do
     end
   end
 end
-EOF
-      end
-
-      def spec_matcher
-        File.open(File.join(repo_name, 'spec', 'support', 'matchers', "#{use_kata_name}.rb"), 'w') {|f| f.write <<EOF}
-RSpec::Matchers.define :your_method do |expected|
-  match do |your_match|
-    #expect(your_match.method_on_object_to_execute).to eq(expected)
-  end
-end
 EOF
       end
     end

data/lib/kata/version.rb

@@ -1,3 +1,3 @@
 module Kata
-  VERSION = '1.5.0'
+  VERSION = '1.6.0'
 end

data/spec/setup/base_spec.rb

@@ -1,5 +1,8 @@
 require 'spec_helper'
 require 'kata/setup/base'
+require 'kata/setup/ruby'
+require 'kata/setup/node'
+require 'kata/setup/php'
 
 module Kata
   module Setup
@@ -14,6 +17,62 @@ module Kata
           expect(s.kata_name).to eq('my-kata')
         end
       end
+
+      describe '#create_repo' do
+        #subject {Kata::Setup::Base.new}
+
+        let(:no_repo) {OpenStruct.new(:repo => false)}
+        let(:with_repo) {OpenStruct.new(:repo => true)}
+
+        it 'only creates if specified' do
+          expect(subject).to_not receive(:create_remote_repo)
+          expect(subject).to receive(:push_local_repo)
+
+          subject.create_repo(no_repo)
+        end
+
+        it 'creates when specified' do
+          expect(subject).to receive(:create_remote_repo)
+          expect(subject).to receive(:push_local_repo)
+
+          subject.create_repo(with_repo)
+        end
+      end
+
+      describe "#build_tree" do
+        subject {Kata::Setup::Base.new}
+
+        let(:ruby_setup) {Kata::Setup::Ruby.new('kata')}
+        let(:node_setup) {Kata::Setup::Node.new('kata')}
+        let(:php_setup) {Kata::Setup::Php.new('kata')}
+
+        it 'invokes the ruby setup' do
+          expect(Kata::Setup::Ruby).to receive(:new).and_return(ruby_setup)
+          expect(ruby_setup).to receive(:build_tree)
+
+          subject.build_tree 'ruby'
+        end
+
+        it 'invokes the node setup' do
+          expect(Kata::Setup::Node).to receive(:new).and_return(node_setup)
+          expect(node_setup).to receive(:build_tree)
+
+          subject.build_tree 'node'
+        end
+
+        it 'invokes the php setup' do
+          expect(Kata::Setup::Php).to receive(:new).and_return(php_setup)
+          expect(php_setup).to receive(:build_tree)
+
+          subject.build_tree 'php'
+        end
+
+        it 'rejects invalid language types' do
+          expect {
+            subject.build_tree 'asdf'
+          }.to raise_error
+        end
+      end
     end
   end
 end

data/spec/setup/{javascript_spec.rb → node_spec.rb}

@@ -1,10 +1,10 @@
 require "spec_helper"
-require "kata/setup/javascript"
+require "kata/setup/node"
 require "fakefs/spec_helpers"
 
 module Kata
   module Setup
-    describe Javascript do
+    describe Node do
       describe "#build_tree" do
         include FakeFS::SpecHelpers
 
@@ -25,11 +25,19 @@ module Kata
           expect(File.exists?(File.join(@use_dir, "README"))).to be true
         end
 
-        it "create base class file" do
+        it "creates package.json file" do
+          expect(File.exists?(File.join(@use_dir, "package.json"))).to be true
+        end
+
+        it "creates autotest file" do
+          expect(File.exists?(File.join(@use_dir, "autotest"))).to be true
+        end
+
+        it "create kata main file" do
           expect(File.exists?(File.join(@use_dir, "lib", "#{subject.kata_name}.js"))).to be true
         end
 
-        it "creates base spec file" do
+        it "creates kata spec file" do
           expect(File.exists?(File.join(@use_dir, "spec", "#{subject.kata_name}_spec.js"))).to be true
         end
       end

data/spec/setup/php_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+require "kata/setup/php"
+require "fakefs/spec_helpers"
+
+module Kata
+  module Setup
+    describe Php do
+      describe "#build_tree" do
+        include FakeFS::SpecHelpers
+
+        before :each do
+          subject.build_tree
+          @use_dir = File.join("/", subject.repo_name)
+
+        end
+
+        let(:class_name) {
+          subject.kata_name.split(/ |-|_/).map(&:capitalize).join
+        }
+
+        it "creates src dir" do
+          expect(File.directory?(File.join(@use_dir, "src"))).to be true
+        end
+
+        it "creates test dir" do
+          expect(File.directory?(File.join(@use_dir, "test"))).to be true
+        end
+
+        it "creates README file" do
+          expect(File.exists?(File.join(@use_dir, "README"))).to be true
+        end
+
+        it "create base class file" do
+          expect(File.exists?(File.join(@use_dir, "src", "#{class_name}.php"))).to be true
+        end
+
+        it "creates base test file" do
+          expect(File.exists?(File.join(@use_dir, "test", "#{class_name}Test.php"))).to be true
+        end
+      end
+    end
+  end
+end

data/spec/setup/ruby_spec.rb

@@ -17,20 +17,20 @@ module Kata
           expect(File.directory?(File.join(@use_dir, "lib"))).to be true
         end
 
-        it "creates spect dir" do
+        it "creates spec dir" do
           expect(File.directory?(File.join(@use_dir, "spec"))).to be true
         end
 
-        it "creates matchers dir" do
-          expect(File.directory?(File.join(@use_dir, "spec", "support", "matchers"))).to be true
+        it "creates README file" do
+          expect(File.exists?(File.join(@use_dir, "README"))).to be true
         end
 
-        it "creates helpers dir" do
-          expect(File.directory?(File.join(@use_dir, "spec", "support", "helpers"))).to be true
+        it "creates bootstrap file" do
+          expect(File.exists?(File.join(@use_dir, "bootstrap.sh"))).to be true
         end
 
-        it "creates README file" do
-          expect(File.exists?(File.join(@use_dir, "README"))).to be true
+        it "creates Gemfile file" do
+          expect(File.exists?(File.join(@use_dir, "Gemfile"))).to be true
         end
 
         it "create base class file" do
@@ -41,17 +41,9 @@ module Kata
           expect(File.exists?(File.join(@use_dir, ".rspec"))).to be true
         end
 
-        it "creates spec helper file" do
-          expect(File.exists?(File.join(@use_dir, "spec", "spec_helper.rb"))).to be true
-        end
-
         it "creates base spec file" do
           expect(File.exists?(File.join(@use_dir, "spec", "#{subject.kata_name}_spec.rb"))).to be true
         end
-
-        it "creates spec matcher file" do
-          expect(File.exists?(File.join(@use_dir, "spec", "support", "matchers", "#{subject.kata_name}.rb"))).to be true
-        end
       end
     end
   end

data/spec/spec_helper.rb

@@ -1,10 +1,13 @@
-$: << "." << File.join(File.dirname(__FILE__), "..", "lib")
+$: << '.' << File.join(File.dirname(__FILE__), '..', 'lib')
 
-require "rspec"
-require "kata/base"
-require "simplecov"
+require 'rspec'
+require 'kata/base'
+require 'simplecov'
+require 'codeclimate-test-reporter'
 
-Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
+CodeClimate::TestReporter.start
+
+Dir[File.dirname(__FILE__) + '/support/**/*.rb'].each {|f| require f}
 
 RSpec.configure do |config|
   config.before(:each) do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kata
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Wes
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-20 00:00:00.000000000 Z
+date: 2014-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,13 +66,15 @@ files:
 - lib/kata.rb
 - lib/kata/base.rb
 - lib/kata/setup/base.rb
-- lib/kata/setup/javascript.rb
+- lib/kata/setup/node.rb
+- lib/kata/setup/php.rb
 - lib/kata/setup/ruby.rb
 - lib/kata/version.rb
 - spec/kata_base_spec.rb
 - spec/kata_spec.rb
 - spec/setup/base_spec.rb
-- spec/setup/javascript_spec.rb
+- spec/setup/node_spec.rb
+- spec/setup/php_spec.rb
 - spec/setup/ruby_spec.rb
 - spec/spec_helper.rb
 - spec/support/helpers/stdout_helper.rb
@@ -104,7 +106,8 @@ test_files:
 - spec/kata_base_spec.rb
 - spec/kata_spec.rb
 - spec/setup/base_spec.rb
-- spec/setup/javascript_spec.rb
+- spec/setup/node_spec.rb
+- spec/setup/php_spec.rb
 - spec/setup/ruby_spec.rb
 - spec/spec_helper.rb
 - spec/support/helpers/stdout_helper.rb