pupu 0.0.1

data/lib/pupu/exceptions.rb

@@ -0,0 +1,21 @@
+module Pupu
+  class PupuRootNotFound < StandardError
+  end
+
+  class PluginNotFoundError < StandardError
+  end
+
+  class PluginIsAlreadyInstalled < StandardError
+  end
+
+  class MediaDirectoryNotExist < StandardError
+  end
+
+  class AssetNotFound < StandardError
+    attr_accessor :path, :message
+    def initialize(path)
+      @path = path
+      @message = "File #{@path} doesn't exist."
+    end
+  end
+end

data/lib/pupu/github.rb

@@ -0,0 +1,121 @@
+require "fileutils"
+require "yaml"
+require "ostruct"
+require "pupu/dsl"
+require "pupu/metadata"
+require "pupu/exceptions"
+
+module ShellExtensions
+  def run(command)
+    puts "[bash] #{command}"
+    %x(#{command})
+    $?.exitstatus == 0
+  end
+end
+
+# TODO: standalone installer class
+module Pupu
+  class GitHub
+    class << self
+      include ShellExtensions
+      # GitHub.install("autocompleter")
+      # GitHub.install("botanicus/autocompleter")
+      def install(repo)
+        user, repo = repo.split("/") if repo.match(%r{/})
+        user = ENV["USER"] unless user
+        url = "git://github.com/#{user}/pupu-#{repo}.git"
+        self.install_files(repo, url)
+        self.install_dependencies(@pupu)
+        # TODO: git commit [files] -m "Added pupu #{repo} from #{url}"
+      end
+
+      def update(pupu_name)
+        if pupu_name
+          pupu = Pupu[pupu_name]
+          if Pupu.strategy.eql?(:submodules)
+            puts %(git fetch)
+            puts %(git reset origin/master --hard)
+          else
+            path = pupu.root.to_s # otherwise after we remove the path, we get error at mkdir telling us that the path doesn't exist
+            pupu.metadata # cache metadata
+            FileUtils.rm_r(path)
+            self.install_files(pupu_name, pupu.metadata.repozitory)
+          end
+        else
+          Pupu.all.each do |pupu_name|
+            self.update(pupu_name)
+          end
+        end
+        pupu.metadata.dependencies.each do |dependency|
+          self.update(dependency)
+        end
+      end
+
+      # search for pupu
+      def search(query)
+        data = YAML::load("http://github.com/api/v1/yaml/search/pupu")
+        data.map! { |result| OpenStruct.new(result) }
+        data.select { |item| item.name.match(query) }
+      end
+
+      protected
+      def save_metadata(pupu, url)
+        revision = %x(git log | head -1).chomp.sub(/^commit /, "")
+        dsl = DSL.new(pupu)
+        dependencies = dsl.get_dependencies.map { |dependency| dependency.name }
+        params = {:revision => revision, :repozitory => url, :dependencies => dependencies}
+        Dir.chdir(@pupu.root.to_s) do
+          File.open("metadata.yml", "w") do |file|
+            file.puts(params.to_yaml)
+          end
+        end
+      end
+
+      def install_dependencies(pupu)
+        dsl = DSL.new(pupu)
+        dsl.instance_eval(File.read(pupu.file("config.rb").path))
+        dsl.get_dependencies.each do |dependency|
+          self.install(dependency.name.to_s) # FIXME: "user/repo"
+        end
+      end
+
+      def install_files(repo, url)
+        chdir do |media_dir|
+          raise PluginIsAlreadyInstalled if File.directory?(repo) # TODO: custom exception class
+          run("git clone #{url} #{repo}") || abort("Git failed")
+          Dir.chdir(repo) do
+            proceed_files(repo, url)
+          end
+        end
+      end
+
+      def proceed_files(repo, url)
+        js_initializer = "initializers/#{repo}.js"
+        css_initializer = "initializers/#{repo}.css"
+        if File.exist?(js_initializer) &&  (not File.exist?("#{::Pupu.media_root}/javascripts/initializers/#{repo}.js"))
+          puts "Creating JS initializer"
+          FileUtils.mkdir_p("#{::Pupu.media_root}/javascripts/initializers")
+          FileUtils.mv js_initializer, "#{::Pupu.media_root}/javascripts/initializers/#{repo}.js"
+        end
+        if File.exist?(css_initializer) && (not File.exist?("#{::Pupu.media_root}/stylesheets/initializers/#{repo}.css"))
+          puts "Creating CSS initializer"
+          FileUtils.mkdir_p("#{::Pupu.media_root}/stylesheets/initializers")
+          FileUtils.mv css_initializer, "#{::Pupu.media_root}/stylesheets/initializers/#{repo}.css"
+        end
+        @pupu = Pupu[repo]
+        self.save_metadata(@pupu, url)
+        FileUtils.rm_r(".git") if Pupu.strategy.eql?(:copy)
+      rescue Exception => exception
+        FileUtils.rm_r(repo) if File.directory?(repo)
+        raise exception
+      end
+
+      def chdir(pupu = nil, &block)
+        FileUtils.mkdir_p(Pupu.root_path) unless File.directory?(Pupu.root_path)
+        Dir.chdir(Pupu.root.to_s) do
+          pupu ? block.call(pupu.root) : block.call(Pupu.root)
+        end
+      end
+    end
+  end
+end

data/lib/pupu/helpers.rb

@@ -0,0 +1,13 @@
+require "pupu/parser"
+
+module Pupu
+  module Helpers
+    # Use it in your layout
+    # Example: pupu :autocompleter, :type => "local"
+    def pupu(name, params = Hash.new)
+      comment = if params.empty? then "<!-- Pupu #{name} without params -->"
+      else "<!-- Pupu #{name} with params #{params.inspect} -->" end
+      [comment, Parser.new(name, params).parse!, "", ""].join("\n")
+    end
+  end
+end

data/lib/pupu/metadata.rb

@@ -0,0 +1,15 @@
+module Pupu
+  class Metadata
+    class << self
+      def load
+        Pupu.all.each do |pupu|
+          pupu.file("config.rb").path
+        end
+      end
+
+      def depends_on(plugin)
+        # TODO
+      end
+    end
+  end
+end

data/lib/pupu/parser.rb

@@ -0,0 +1,47 @@
+require "pupu/dsl"
+require "pupu/pupu"
+
+module Pupu
+  class Parser
+    def initialize(plugin_name, plugin_params)
+      @plugin    = Pupu[plugin_name, plugin_params]
+      @output    = Array.new
+      @dsl       = DSL.new(@plugin)
+      @@loaded ||= Hash.new
+      @@loaded[@plugin.name] = Array.new
+    end
+
+    def loaded?
+      # The reason why just array with plugin names isn't enough is that every time it can be called
+      # with different parameters. For example pupu :mootools and then pupu :mootools, :more => true
+      @@loaded[@plugin.name] && @dsl.files.all? do |file|
+        @@loaded[@plugin.name].include?(file)
+      end
+
+      false # FIXME: there is a bug in this method, it returns true in every case (not so important)
+    end
+
+    def add_initializers
+      js_initializer  = @plugin.initializer(:javascript)
+      css_initializer = @plugin.initializer(:stylesheet)
+      @output.push("\n<link href='#{css_initializer.url}' media='screen' rel='stylesheet' type='text/css' />") if css_initializer
+      @output.push("\n<script src='#{js_initializer.url}' type='text/javascript'></script>") if js_initializer
+    end
+
+    def add_dependencies
+      @dsl.get_dependencies.each do |dependency|
+        parser = Parser.new(dependency.name, dependency.params)
+        @output.push(parser.parse!) unless parser.loaded?
+      end
+    end
+
+    def parse!
+      @dsl.instance_eval(File.read(@plugin.file("config.rb").path))
+      self.add_dependencies
+      @@loaded[@plugin.name].push(*@dsl.files)
+      @output.push(@dsl.output)
+      self.add_initializers
+      return @output.join("\n")
+    end
+  end
+end

data/lib/pupu/pupu.rb

@@ -0,0 +1,142 @@
+require "yaml"
+require "ostruct"
+require "fileutils"
+require "media-path"
+require "pupu/exceptions"
+require "pupu/metadata"
+
+module Pupu
+  # this must be set in adapters
+  class << self
+    attr_accessor :root
+
+    # @example Pupu.media_prefix("media").url
+    #   => "/media/pupu/autocompleter/javascripts/autocompleter.js"
+    def media_prefix=(prefix)
+      MediaPath.rewrite { |path| File.join(prefix, path) }
+    end
+
+    # TODO: media_root or media_root?
+    def media_root=(path)
+      MediaPath.media_root = path
+      @media_root = path
+    end
+    attr_reader :media_root
+
+    # @example Pupu.rewrite { |path| "http://media.domain.org/#{path}" }.url
+    #   # => "http://media.domain.org/pupu/autocompleter/javascripts/autocompleter.js"
+    def rewrite(&block)
+      MediaPath.rewrite(&block)
+    end
+  end
+
+  class Pupu
+    class << self
+      # TODO: return Pupu object, not string
+      def all
+        Dir["#{self.root}/*"].select do |item|
+          File.directory?(item)
+        end.map { |entry| File.basename(entry).to_s }
+      end
+
+      # same as root, but doesn't raise any exception
+      def root_path
+        File.join(::Pupu.media_root, "pupu")
+      end
+
+      # strategies: submodules, copy
+      cattr_accessor :strategy
+
+      def root
+        # TODO: it should be configurable
+        # root = ::Pupu.root.sub(%r[#{Regexp::quote(::Pupu.root)}], '').chomp("/")
+        # root = "./" if root.empty?
+        # case path
+        #  when :absolute then File.join(root, ::Pupu.media_root, "pupu")
+        #  when :relative then File.join(::Pupu.media_root, "pupu")
+        #  else
+        #    # exception
+        #  end
+        raise "Pupu.media_root has to be initialized" if ::Pupu.media_root.nil?
+        raise Errno::ENOENT, "#{::Pupu.media_root}/pupu doesn't exist, you have to create it first!" unless File.directory?File.join(::Pupu.media_root, "pupu")
+        @root ||= MediaPath.new(File.join(::Pupu.media_root, "pupu"))
+      end
+
+      # TODO: reflect changes on root method
+      def root=(directory)
+        @root = MediaPath.new(directory)
+        raise PupuRootNotFound unless File.exist?(@root.to_s)
+        return @root
+      end
+
+      def [](plugin, params = Hash.new)
+        plugin = plugin.to_s
+        if self.all.include?(plugin)
+          self.new(plugin, params)
+        else
+          raise PluginNotFoundError
+        end
+      end
+    end
+
+    attr_reader :name, :params
+    def initialize(name, params = Hash.new)
+      @name   = name.to_sym
+      @path   = name.to_s
+      @params = params
+    end
+
+    def root
+      self.class.root.join(@path)
+    end
+
+    def metadata
+      return @metadata if @metadata
+      path = self.file("metadata.yml").path
+      hash = YAML::load_file(path)
+      @metadata = OpenStruct.new(hash)
+    rescue Errno::ENOENT # we might remove pupu directory, so metadata are missing, but we can get them from cache
+      @metadata
+    end
+
+    def javascript(basename)
+      file("javascripts/#{basename}.js")
+    end
+
+    def stylesheet(basename)
+      file("stylesheets/#{basename}.css")
+    end
+
+    def image(basename)
+      file("javascripts/#{image}")
+    end
+
+    def uninstall
+      FileUtils.rm_r self.root.to_s
+      # TODO
+      # self.metadata.dependants.each do |dependant|
+      #   dependant.uninstall
+      # end
+    end
+
+    def initializer(type = :all)
+      case type
+      when :all
+        [self.initializer(:javascript), self.initializer(:stylesheet)]
+      when :javascript
+        file("#{@path}.js", "#{::Pupu.media_root}/javascripts/initializers") rescue nil # TODO: fix media
+      when :stylesheet
+        file("#{@path}.css", "#{::Pupu.media_root}/stylesheets/initializers") rescue nil # TODO: fix media
+      end
+    end
+
+    def soft_file(path, root = self.root)
+      File.join(root.to_s, path.to_s) # for files which doesn't exist so far
+    end
+
+    def file(path, root = self.root)
+      root = MediaPath.new(root) if root.is_a?(String)
+      root.join(path)
+    end
+  end
+end

data/lib/pupu/tasks/pupu.rake

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+# == How Rake Works with Arguments ==
+# http://rubyforge.org/pipermail/rake-devel/2007-December/000352.html
+
+# == Setup ==
+# task "pupu:setup" => :environment
+namespace :pupu do
+  task :load do
+    require "pupu/cli"
+  end
+
+  desc "Setup hook for tasks which require to have Pupu.root and Pupu.media_root set"
+  task setup: "pupu:load"
+
+  # Run rake pupu:install[mootools-core,mootools-more]
+  desc "Install pupu"
+  task :install, [:name] => "pupu:setup" do |task, args|
+    Pupu::CLI.install(args.name)
+  end
+
+  desc "Uninstall given pupu"
+  task :uninstall, [:name] => "pupu:setup" do |task, args|
+    Pupu::CLI.uninstall(args.name)
+  end
+
+  desc "Update given pupu if an argument given, otherwise update all pupus"
+  task :update, [:name] => "pupu:setup" do |task, args|
+    args = [args.name] ? args.name : Array.new
+    Pupu::CLI.update(*args)
+  end
+
+  desc "List all installed pupus"
+  task list: "pupu:setup" do
+    Pupu::CLI.list
+  end
+
+  desc "Search pupu matching given pattern on GitHub"
+  task :search, [:pattern] => "pupu:load" do |task, args|
+    Pupu::CLI.search(args.pattern)
+  end
+end

data/lib/pupu/tasks/pupu.thor

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+# Pupu::Tasks.class_eval do
+#   def setup
+#     load "config/environment.rb"
+#   end
+# end
+
+module Pupu
+  class Tasks < Thor
+    def initialize
+      require "pupu/cli"
+      self.setup
+    end
+
+    # self.namespace = "pupu" # TODO: patch thor
+    desc "install [*pupu]", "Install given pupu"
+    def install(*pupus)
+      CLI.install(*pupus)
+    end
+
+    desc "update [*pupu]", "Update given pupu if an argument given, otherwise update all pupus"
+    def update(*pupus)
+      CLI.update(*pupus)
+    end
+
+    desc "uninstall [*pupu]", "Uninstall given pupu"
+    def uninstall(*pupus)
+      CLI.uninstall(*pupus)
+    end
+
+    desc "list", "Show installed pupus"
+    def list
+      CLI.list
+    end
+
+    desc "search [pattern]", "Search remote pupus"
+    def search(pattern = nil)
+      CLI.search(pattern)
+    end
+
+    protected
+    # Setup hook for tasks which require to have Pupu.root and Pupu.media_root set
+    def setup
+      load "config/pupu.rb"
+    end
+  end
+end