zizu 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+zizu*.gem

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem "colorize"
+gem "github_api"
+gem "haml"
+gem "highline"
+gem "rack"
+gem "thin"
+gem "thor"
+gem "tilt"
+gem "zip"
+

data/Gemfile.lock

@@ -0,0 +1,57 @@
+PATH
+  remote: .
+  specs:
+    zizu (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    colorize (0.5.8)
+    daemons (1.1.9)
+    eventmachine (1.0.0)
+    faraday (0.8.4)
+      multipart-post (~> 1.1)
+    github_api (0.8.4)
+      faraday (~> 0.8.1)
+      hashie (~> 1.2.0)
+      multi_json (~> 1.4)
+      nokogiri (~> 1.5.2)
+      oauth2
+    haml (3.1.7)
+    hashie (1.2.0)
+    highline (1.6.15)
+    httpauth (0.2.0)
+    jwt (0.1.5)
+      multi_json (>= 1.0)
+    multi_json (1.5.0)
+    multipart-post (1.1.5)
+    nokogiri (1.5.6)
+    oauth2 (0.8.0)
+      faraday (~> 0.8)
+      httpauth (~> 0.1)
+      jwt (~> 0.1.4)
+      multi_json (~> 1.0)
+      rack (~> 1.2)
+    rack (1.4.1)
+    thin (1.5.0)
+      daemons (>= 1.0.9)
+      eventmachine (>= 0.12.6)
+      rack (>= 1.0.0)
+    thor (0.16.0)
+    tilt (1.3.3)
+    zip (2.0.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  colorize
+  github_api
+  haml
+  highline
+  rack
+  thin
+  thor
+  tilt
+  zip
+  zizu!

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+Copyright (c) 2012 Stephen Hu
+
+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,40 @@
+# zizu
+
+zizu is an opinionated static site generator based on bootstrap, haml, html5,
+and github.
+
+## requirements
+
+* bundler
+* github_api
+* haml
+* thor
+* tilt
+
+## installation
+
+### gem package
+
+1.  install the gem from rubygems
+```gem install zizu-0.0.1.gem```
+
+### from source
+
+1.  clone the repository
+```git clone git@github.com:stephenhu/zizu```
+2.  install dependencies
+```bundle install # from the zizu root directory```
+3.  build the gem
+```gem build zizu.gemspec # from the zizu root directory```
+4.  install the local gem
+```gem install zizu-0.0.1.gem``` 
+
+## faq
+
+1.  what does zizu stand for?
+```zizu is the chinese pin yin for spider, technically it should be zhizhu,
+but that's a bit harder to type.```
+2.  are sinatra haml files compatible with zizu?
+```technically i tried to keep the syntax consistent with sinatra since i'm
+a big fan, so i mocked _haml_ and _url_ functions.```
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/zizu

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require "zizu"
+Zizu::CLI.start
+

data/conf/zizu.yaml

@@ -0,0 +1,3 @@
+templates: layout.haml, navbar.haml, footer.haml
+
+

data/docs/backlog

@@ -0,0 +1,6 @@
+- add rspec tests
+- prompt user on overwriting existing files
+- add in configuration file to ~/.zizu
+- download prettify
+- download jqueryui
+

data/docs/design

@@ -0,0 +1,33 @@
+zizu is an opinionated static site generator based on bootstrap, haml, html5,
+and github.
+
+zizu can:
+
+1.  fork site skeleton (fork generic templates)
+2.  create repositories on github
+3.  generate static site files
+4.  push/pull sources to github
+5.  deploy to github pages
+
+x.  deploy to bitbucket
+x.  pull sources from local git
+x.  deploy to other hosts via sftp
+x.  run locally for development purposes
+
+repositories:
+
+1.  source (haml)
+2.  destination (html)
+
+commands:
+
+# creates remote repository and syncs
+zizu create NAME
+
+# converts haml to html
+zizu compile
+
+# push to remote repository
+zizu deploy REPOSITORY
+
+

data/lib/zizu.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+require "base64"
+require "colorize"
+require "github_api"
+require "haml"
+require "highline/import"
+require "open3"
+require "open-uri"
+require "rack"
+require "thor"
+require "tilt"
+require "yaml"
+require "zip/zip"
+
+require File.join( File.dirname(__FILE__), "zizu", "githublib" )
+require File.join( File.dirname(__FILE__), "zizu", "gitlib" )
+require File.join( File.dirname(__FILE__), "zizu", "version" )
+require File.join( File.dirname(__FILE__), "zizu", "cli" )
+
+def haml(file)
+  return Tilt.new("#{file}.haml").render
+end
+
+def url(location)
+  # TODO add some logic to filter the url address
+  return location
+end
+
+module Zizu
+
+  USER        = "stephenhu"
+  REPOSITORY  = "bootstrap-haml"
+  EXCLUDES    = [ "layout.haml", "navbar.haml", "footer.haml" ]
+  BOOTSTRAP   = "http://twitter.github.com/bootstrap/assets/bootstrap.zip"
+
+  def self.fatal(msg)
+    puts msg.red
+    exit
+  end
+
+  def self.warning(msg)
+    puts msg.yellow
+  end
+
+  def self.info(msg)
+    puts msg
+  end
+
+  def self.success(msg)
+    puts msg.green
+  end
+
+end
+

data/lib/zizu/cli.rb

@@ -0,0 +1,246 @@
+module Zizu
+
+  class CLI < Thor
+
+    desc( "create NAME", "create site skeleton" )
+    method_option :fork, :aliases => "-f", :type => :boolean,
+      :default => false, :required => false, :desc => "fork repo"
+    def create(name)
+
+      if File.directory?(name)
+        Zizu::fatal("directory already exists, init aborted")
+      else
+
+        if options[:fork]
+          fork(name)
+        else
+          create_skeleton(name)  
+        end
+
+      end
+
+    end
+
+    desc( "compile", "compile template files to .html" )
+    method_option :exclude, :aliases => "-x", :type => :string,
+      :required => false, :desc => "files to exclude from compilation, " +
+      "use comma separate multiple files"
+    method_option :output, :aliases => "-o", :type => :string,
+      :required => false, :desc => "output path for compiled files"
+    def compile
+
+      excludes  = check_exclusions(options[:exclude])
+
+      unless options[:output].nil?
+        dir = create_directory(options[:output])
+      end
+
+      basedir = "."
+
+      haml_files = Dir.glob("*.haml")
+
+      init_templates
+
+      haml_files.each do |f|
+
+        if excludes.include?(f)
+          next
+        else
+
+          html      = haml_to_html(f)
+
+          if dir.nil?
+            html_name = f.chomp(".haml") + ".html"
+          else
+            html_name = dir + f.chomp(".haml") + ".html"
+          end
+
+          f = File.open( html_name, "w" )
+          f.write(html)
+          f.close
+
+          Zizu::success("created #{html_name}")
+
+        end
+
+      end
+
+      unless dir.nil?
+
+        FileUtils.cp_r( "scripts", dir )
+        Zizu::success("copying scripts directory")
+
+        FileUtils.cp_r( "styles", dir )
+        Zizu::success("copying styles directory")
+
+        FileUtils.cp_r( "images", dir )
+        Zizu::success("copying images directory")
+
+      end
+ 
+    end
+
+    desc( "stage", "stage environment locally for testing")
+    def stage 
+
+      get_rack
+      get_bootstrap
+
+      Zizu::info("run the 'rackup' command to start the server locally")
+
+    end
+
+    #desc( "deploy", "deploy static files to production" )
+    #method_option :target, :aliases => "-t", :required => false
+    #def deploy
+
+    #  g = GithubLib.new
+
+    #  latest = g.get_latest_commit()
+
+    #  tree = g.get_tree(latest)
+    #  g.download_files(tree)
+
+    #end
+
+    no_tasks do
+
+      def fork(name)
+
+        g = GithubLib.new    
+
+        # TODO make atomic
+        git_url = g.fork( USER, REPOSITORY )
+
+        unless git_url.nil?
+
+          new_url = g.set_repository_name( REPOSITORY, name )
+
+          if g.check_exists?(name)
+            # TODO retry if it doesn't exist since this is asynch
+            if Gitlib.clone( new_url, name )
+              Zizu::success("repository cloned to local")
+            else
+
+              Zizu::fatal("unable clone remote repository")
+              g.delete_repository(REPOSITORY)
+
+            end
+
+          else
+            Zizu::fatal("repository rename failed, aborting operation")
+            g.delete_repository(REPOSITORY)
+          end
+
+        else
+          Zizu::fatal("fork failed, aborting operation")
+        end
+
+      end
+
+      def get_rack
+
+        configru = File.join( File.dirname(__FILE__), "config.ru" )
+        FileUtils.cp( configru, "." ) unless File.exists?("./config.ru")
+
+        Zizu::success("rackup configuration (config.ru) installed")
+
+      end
+
+      def get_bootstrap
+
+        bootstrap = open(BOOTSTRAP)
+
+        Zip::ZipFile.open(bootstrap.path) do |z|
+
+          z.each do |f|
+            path = File.join( ".", f.name )
+            FileUtils.mkdir_p(File.dirname(path))
+            z.extract( f, path ) unless File.exist?(path)
+          end
+
+        end
+
+        Zizu::success("bootstrap latest installed")
+
+      end
+
+      def get_dependencies
+
+        # bootstrap
+
+      end
+
+      def check_exclusions(excludes_str)
+
+        if excludes_str.nil?
+          return EXCLUDES
+        else
+
+           user_excludes = excludes_str.split(",").each { |e| e.strip! }
+           user_excludes = user_excludes + EXCLUDES
+           user_excludes.uniq!
+           return user_excludes
+
+        end
+
+      end
+
+      def create_skeleton(name)
+
+        dirs = [ "images", "styles", "scripts", "conf" ]
+
+        dirs.each do |d|
+          create_directory( "#{name}/#{d}")
+        end
+
+        # copy from github or store locally?  if no network?
+        # TODO how about a reverse html to haml?
+
+        g = GithubLib.new
+
+        latest = g.get_latest_commit()
+
+        tree = g.get_tree(latest)
+        g.download_files( tree, name )
+
+      end
+
+      def create_directory(name)
+
+        if name.nil?
+          Zizu::fatal("no directory name specified")
+        else
+
+          FileUtils.mkdir_p(name) unless File.directory?(name)
+          Zizu::success("#{name} directory created")
+
+        end
+                                                                            
+      end
+
+      def init_templates
+
+        @layout = Tilt.new("layout.haml") if File.exists?("layout.haml")
+        @navbar = Tilt.new("navbar.haml") if File.exists?("navbar.haml")
+        @footer = Tilt.new("footer.haml") if File.exists?("footer.haml")
+
+      end
+
+      def haml_to_html(template)
+
+        unless @layout.nil?
+          html = @layout.render { Tilt.new(template).render }
+          return html
+        end
+
+        Zizu::fatal("layout.haml template is missing, aborting compile")
+
+      end
+
+    end
+
+  end
+
+end
+

data/lib/zizu/config.ru

@@ -0,0 +1,2 @@
+run Rack::Directory.new(".")
+

data/lib/zizu/githublib.rb

@@ -0,0 +1,192 @@
+module Zizu
+
+  class GithubLib
+
+    attr_accessor :api
+
+    def initialize
+      login
+    end
+
+
+    def login
+
+      if @api.nil?                                                           
+ 
+        config = Gitlib.config
+
+        @login     = ENV["ZIZU_GIT_LOGIN"] || config["user.name"]
+
+        if @login == USER
+          Zizu::fatal("cannot fork a project that you own, aborting")
+        end
+
+        @password  = ENV["ZIZU_GIT_PASSWORD"] ||
+          ask("git password: ") { |q| q.echo = "*" }
+
+        if @login.nil? or @password.nil?
+          Zizu::fatal("please set git config variable user.name or env variable ZIZU_GIT_LOGIN.")
+        end
+
+        @api = Github.new( login:@login, password:@password )
+
+        if @api.nil?
+          Zizu::fatal("login failed")
+        end
+
+      end
+
+    end
+
+    def fork( user, repo )
+
+      unless fork_exists?("#{user}/#{repo}")
+
+        response = @api.repos.forks.create( user, repo )
+
+        if response.success?
+          Zizu::success("repository forked to: #{response[:git_url]}")
+          return response[:git_url]
+        end
+
+      end
+
+      return nil 
+
+    end
+
+    def fork_exists?(full_name)
+
+      response = @api.repos.list( :user => @login )
+
+      response.each do |r|
+
+        user, repo = r[:full_name].split("/")
+        get_r = @api.repos.get( user, repo )
+
+        if get_r.success?
+
+          if get_r[:fork] and get_r[:parent][:full_name] == full_name
+            Zizu::fatal(
+              "repository has already been forked: #{get_r[:git_url]}")
+            return true
+          end
+
+        else
+          Zizu::fatal("Error: #{get_r.status}")
+          Zizu::fatal(get_r.body)
+        end
+
+      end
+
+      return false
+
+    end
+
+    def check_exists?(repo)
+
+      response = @api.repos.get( @login, repo )
+
+      if response.success?
+        return true
+      else
+        return false
+      end
+
+    end
+
+    def set_repository_name( repository, new_name )
+
+      response = @api.repos.edit( @login, repository, :name => new_name )
+
+      if response.success?
+        Zizu::success("Repository successfully renamed to #{new_name}")
+        Zizu::success(response[:git_url])
+        return response[:git_url] 
+      else
+        Zizu::fatal("GithubLib Error: #{response.status}")
+        return nil
+      end
+
+    end
+
+    def delete_repository(name)
+
+      puts @login
+      puts "rollback"
+
+      #response = @api.repos.delete( @login, name )
+
+    end
+
+    def get_latest_commit
+
+      response = @api.repos.commits.list( USER, REPOSITORY )
+
+      if response.success?
+        return response[0][:sha]
+      else
+        fatal("unable to retrieve latest commit hash")
+      end
+
+    end
+
+    def get_tree(id)
+
+      #latest = get_latest_commit
+
+      response = @api.git_data.trees.get( USER, REPOSITORY, id )
+
+      if response.success?
+        return response[:tree]
+      else
+        fatal("unable to retrieve tree for #{id}")
+      end
+
+    end
+
+    def download_files( tree, dir=nil )
+
+      tree.each do |t|
+
+        if t["type"] == "tree"
+
+          if dir.nil?
+            new_path = t["path"]
+          else
+            new_path = "#{dir}/#{t["path"]}"
+          end
+
+          FileUtils.mkdir_p(new_path)
+          download_files( get_tree(t["sha"]), new_path )
+          next
+
+        else
+
+          data = open(t["url"])
+          json = JSON.parse(data.read())
+
+          unless json["content"].nil?
+
+            if dir.nil?
+              f = File.open( t["path"], "w" )
+            else
+              f = File.open( "#{dir}/#{t["path"]}", "w" )
+            end
+
+            contents = Base64.decode64(json["content"])
+            f.write(contents)
+            f.close
+
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end
+

data/lib/zizu/gitlib.rb

@@ -0,0 +1,66 @@
+module Zizu
+
+  module Gitlib 
+
+    def self.cmd(str)
+
+      stdin, stdout, stderr = Open3.popen3(str)
+
+      err = stderr.read.chomp
+
+      return { :stdout => stdout.read.chomp, :stderr => err,
+        :status => err.length > 0 ? false : true }
+
+    end
+
+    def self.version
+
+      r = cmd("git --version")
+      tokens = r[:stdout].split(" ")
+      return tokens[-1]
+
+    end
+
+    def self.config
+
+      configs = Hash.new
+
+      r = cmd("git config -l")
+
+      if r[:status]
+
+        # TODO windows and mac support
+        params = r[:stdout].split("\n")
+
+        params.each do |p|
+          key, value = p.split("=")
+          configs[key.strip] = value.strip
+        end
+
+        return configs
+
+      else
+        Zizu::fatal("command failed")
+        return nil
+      end
+
+    end
+
+    def self.clone( url, dest=nil )
+
+      r = cmd("git clone #{url} #{dest}")
+
+      if r[:status]
+        Zizu::success(r[:stdout])
+      else
+        Zizu::fatal(r[:stderr])
+      end
+
+      return r[:status]
+
+    end
+
+  end
+
+end
+

data/lib/zizu/version.rb

@@ -0,0 +1,3 @@
+module Zizu
+  VERSION = "0.0.1"
+end

data/zizu.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-                                                       
+require File.expand_path('../lib/zizu/version', __FILE__)
+
+Gem::Specification.new do |gem|
+
+  gem.name            = "zizu"
+  gem.platform        = Gem::Platform::RUBY
+  gem.version         = Zizu::VERSION
+  gem.license         = "MIT"
+  gem.date            = "2012-12-23"
+  gem.summary         = "zizu cli"
+  gem.description     = "static site generator and deployment tool."
+  gem.authors         = %w(stephenhu)
+  gem.email           = "epynonymous@outlook.com"
+  gem.homepage        = "http://github.com/stephenhu/zizu"
+
+  gem.require_paths   = %w(lib)
+  gem.bindir          = "bin"
+  gem.files           = `git ls-files`.split($\)                                  
+  #gem.executables     = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.executables     = %w(zizu)
+
+  #gem.add_dependency  "rgit"
+
+end
+

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: zizu
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- stephenhu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-23 00:00:00.000000000 Z
+dependencies: []
+description: static site generator and deployment tool.
+email: epynonymous@outlook.com
+executables:
+- zizu
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/zizu
+- conf/zizu.yaml
+- docs/backlog
+- docs/design
+- lib/zizu.rb
+- lib/zizu/cli.rb
+- lib/zizu/config.ru
+- lib/zizu/githublib.rb
+- lib/zizu/gitlib.rb
+- lib/zizu/version.rb
+- zizu.gemspec
+homepage: http://github.com/stephenhu/zizu
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: zizu cli
+test_files: []