ro 1.4.6 → 4.2.0

data/lib/ro/git.rb

@@ -1,374 +0,0 @@
-module Ro
-  class Git
-    attr_accessor :root
-    attr_accessor :branch
-    attr_accessor :patching
-
-    def initialize(root, options = {})
-      options = Map.for(options)
-
-      @root = root
-      @branch = options[:branch] || 'master'
-    end
-
-  # patch takes a block, allows abitrary edits (additions, modifications,
-  # deletions) to be performed by it, and then computes a single, atomic patch
-  # that is applied to the repo and pushed.  the patch is returned.  if the
-  # patch was not applied then patch.applied==false and it's up to client code
-  # to decide how to proceed, perhaps retrying or saving the patchfile for
-  # later manual application
-  #
-    def patch(*args, &block)
-      options = Map.options_for!(args)
-
-      user = options[:user] || ENV['USER'] || 'ro'
-      msg = options[:message] || "#{ user } edits on #{ File.basename(@root).inspect }"
-      add = options.has_key?(:add) ? options[:add] : true
-
-      patch = nil
-
-      Thread.exclusive do
-        @root.lock do
-          Dir.chdir(@root) do
-            # ensure .git-ness
-            #
-              status, stdout, stderr = spawn("git rev-parse --git-dir", :raise => true, :capture => true)
-
-              git_root = stdout.to_s.strip
-
-              dot_git = File.expand_path(git_root)
-
-              unless test(?d, dot_git)
-                raise Error.new("missing .git directory #{ dot_git }")
-              end
-
-            # calculate a tmp branch name
-            #
-              time = Coerce.time(options[:time] || Time.now).utc.iso8601(2).gsub(/[^\w]/, '')
-              branch = "#{ user }-#{ time }-#{ rand.to_s.gsub(/^0./, '') }"
-
-            # allow block to edit, compute the patch, attempt to apply it
-            #
-              begin
-              # get pristine
-              #
-                spawn("git checkout -f master", :raise => true)
-                spawn("git fetch --all", :raise => true)
-                spawn("git reset --hard origin/master", :raise => true)
-
-              # pull recent changes
-              #
-                trying('to pull'){ spawn("git pull origin master") }
-
-              # create a new temporary branch
-              #
-                spawn("git checkout -b #{ branch.inspect }", :raise => true)
-
-              # the block can perform arbitrary edits
-              #
-                block.call
-
-              # add all changes - additions, deletions, or modifications - unless :add => false was specified
-              #
-                if add
-                  spawn("git add . --all", :raise => true)
-                end
-
-              # commit if anything changed
-              #
-                changes_to_apply =
-                  spawn("git commit -m #{ msg.inspect }")
-
-                if changes_to_apply
-                # create the patch
-                #
-                  status, stdout, stderr =
-                    spawn("git format-patch master --stdout", :raise => true, :capture => true)
-
-                  patch = Patch.new(:data => stdout, :name => branch)
-
-                  unless stdout.to_s.strip.empty?
-                  # apply the patch
-                  #
-                    spawn("git checkout master", :raise => true)
-
-                  #
-                    spawn("git rebase --abort")
-                    spawn("git am --abort")
-
-                    spawn("git am --abort")
-                    spawn("git rebase --abort")
-
-                  #
-                    status, stdout, stderr =
-                      spawn("git am --signoff --3way --ignore-space-change --ignore-whitespace", :capture => true, :stdin => patch.data)
-
-                  #
-                    patch.applied = !!(status == 0)
-
-                  # commit the patch back to the repo
-                  #
-                    patch.committed =
-                      begin
-                        trying('to pull'){ spawn("git pull origin master") }
-                        trying('to push'){ spawn("git push origin master") }
-                        true
-                      rescue Object
-                        false
-                      end
-                  end
-                end
-              ensure
-              # get pristine
-              #
-                spawn("git checkout -f master", :raise => true)
-                spawn("git fetch --all", :raise => true)
-                spawn("git reset --hard origin/master", :raise => true)
-
-                spawn("git am --abort")
-                spawn("git rebase --abort")
-
-              # get changes
-              #
-                trying('to pull'){ spawn("git pull") }
-
-              # nuke the tmp branch
-              #
-                if patch and patch.applied and patch.committed
-                  spawn("git branch -D #{ branch.inspect }")
-                end
-              end
-          end
-        end
-      end
-
-      patch
-    end
-
-  #
-    class Patch
-      fattr :data
-      fattr :name
-      fattr :applied
-      fattr :committed
-      fattr :status
-      fattr :stdout
-      fattr :stderr
-
-      def initialize(*args)
-        options = Map.options_for!(args)
-
-        self.class.fattrs.each do |key|
-          send(key, options.get(key)) if options.has?(key)
-        end
-
-        unless args.empty?
-          self.data = args.join
-        end
-      end
-
-      def save(path)
-        return false unless data
-        path = path.to_s
-        FileUtils.mkdir_p(File.dirname(path))
-        IO.binwrite(path, data)
-      end
-
-      %w( to_s to_str ).each do |method|
-        class_eval <<-__, __FILE__, __LINE__
-          def #{ method }
-            data
-          end
-        __
-      end
-
-      %w( filename pathname basename ).each do |method|
-        class_eval <<-__, __FILE__, __LINE__
-          def #{ method }
-            name
-          end
-        __
-      end
-
-      %w( success success? applied applied? ).each do |method|
-        class_eval <<-__, __FILE__, __LINE__
-          def #{ method }
-            status && status == 0
-          end
-        __
-      end
-    end
-
-
-
-    def save(directory, options = {})
-      if directory.is_a?(Node)
-        directory = directory.path
-      end
-
-      options = Map.for(options)
-
-      dir = File.expand_path(directory.to_s)
-
-      relative_path = Ro.relative_path(dir, :from => @root)
-
-      exists = test(?d, dir)
-
-      action = exists ? 'edited' : 'created'
-
-      msg = options[:message] || "#{ ENV['USER'] } #{ action } #{ relative_path }"
-
-      @root.lock do
-        FileUtils.mkdir_p(dir) unless exists
-
-        Dir.chdir(dir) do
-        # .git
-        #
-          status, stdout, stderr = spawn("git rev-parse --git-dir", :raise => true, :capture => true)
-
-          git_root = stdout.to_s.strip
-
-          dot_git = File.expand_path(git_root)
-
-          unless test(?d, dot_git)
-            raise Error.new("missing .git directory #{ dot_git }")
-          end
-
-        # correct branch
-        #
-          spawn("git checkout #{ @branch.inspect }", :raise => true)
-
-        # return if nothing to do...
-        #
-          if `git status --porcelain`.strip.empty?
-            return true
-          end
-
-        # commit the work
-        #
-          trying "to commit" do
-
-            committed = 
-              spawn("git add --all . && git commit -m #{ msg.inspect } -- .")
-
-=begin
-            unless committed
-              spawn "git reset --hard"
-            end
-=end
-
-#require 'pry'
-#binding.pry
-=begin
-            retried = false
-            begin
-              spawn "git add --all . && git commit -m #{ msg.inspect } -- ."
-              committed = true
-            rescue
-              raise if retried
-              spawn "git reset --hard", :raise => false
-              retry
-            end
-=end
-          end
-
-
-          trying "to push" do
-            pushed = nil
-
-            unless spawn("git push origin master")
-            # merge
-            #
-              unless spawn("git pull")
-                spawn("git checkout --ours -- .")
-                spawn("git add --all .")
-                spawn("git commit -F #{ dot_git }/MERGE_MSG")
-              else
-                raise 'wtf!?'
-              end
-
-              pushed = spawn("git push origin master")
-            else
-              pushed = true
-            end
-
-            pushed
-          end
-
-=begin
-  git push
-
-    git pull
-
-      # publish
-      git checkout --ours -- .
-      git add --all .
-      git commit -F .git/MERGE_MSG
-      git push
-=end
-
-
-
-        end
-      end
-    end
-
-    class Error < ::StandardError;end
-
-    def trying(*args, &block)
-      options = Map.options_for!(args)
-      label = ['trying', *args].join(' - ')
-
-      n = Integer(options[:n] || 3)
-      timeout = options[:timeout]
-      e = nil
-      done = nil
-      not_done = Object.new.freeze
-
-      result =
-        catch(:trying) do
-          n.times do |i|
-            done = block.call
-            if done
-              throw(:trying, done)
-            else
-              unless timeout == false
-                sleep( (i + 1) * (timeout || (1 + rand)) )
-              end
-            end
-          end
-
-          not_done
-        end
-
-      if result == not_done
-        raise(Error.new("#{ label } failed #{ n } times"))
-      else
-        done
-      end
-    end
-
-    def spawn(command, options = {})
-      options = Map.for(options)
-
-      status, stdout, stderr = systemu(command, :stdin => options[:stdin])
-
-      Ro.log(:debug, "command: #{ command }")
-      Ro.log(:debug, "status: #{ status }")
-      Ro.log(:debug, "stdout:\n#{ stdout }")
-      Ro.log(:debug, "stderr:\n#{ stderr }")
-
-      if options[:raise] == true
-        unless status == 0
-          raise "command (#{ command }) failed with #{ status }"
-        end
-      end
-
-      if options[:capture]
-        [status, stdout, stderr]
-      else
-        status == 0
-      end
-    end
-  end
-end

data/lib/ro/initializers/env.rb

@@ -1,5 +0,0 @@
-module Ro
-  if ENV['RO_DEBUG']
-    Ro.debug!
-  end
-end

data/lib/ro/initializers/tilt.rb

@@ -1,104 +0,0 @@
-require 'tilt'
-
-module Tilt
-  class SyntaxHighlightingRedcarpetTemplate < Template
-    self.default_mime_type = 'text/html'
-
-    def self.engine_initialized?
-      defined?(::Redcarpet) && defined?(::Pygments) && defined?(::ERB)
-    end
-
-    def initialize_engine
-      require_template_library('redcarpet')
-      require_template_library('pygments')
-      require_template_library('erb')
-    end
-
-    def prepare
-      @engine =
-        Redcarpet::Markdown.new(
-          syntax_highlighting_renderer,
-      
-          :no_intra_emphasis            => true,
-          :tables                       => true,
-          :fenced_code_blocks           => true,
-          :autolink                     => true,
-          :disable_indented_code_blocks => true,
-          :strikethrough                => true,
-          :lax_spacing                  => true,
-          :space_after_headers          => false,
-          :superscript                  => true,
-          :underline                    => true,
-          :highlight                    => true,
-          :quote                        => true,
-
-          :with_toc_data                => true,
-          :hard_wrap                    => true,
-        )
-
-      @output = nil
-    end
-
-    def syntax_highlighting_renderer
-      Class.new(Redcarpet::Render::HTML) do
-        def block_code(code, language)
-          language = 'ruby' if language.to_s.strip.empty?
-          ::Pygments.highlight(code, :lexer => language, :options => {:encoding => 'utf-8'})
-        end
-      end
-    end
-
-    def evaluate(scope, locals, &block)
-      binding =
-        if scope.is_a?(::Binding)
-          scope
-        else
-          scope.instance_eval{ ::Kernel.binding }
-        end
-
-      @engine.render(erb(data, binding))
-    end
-    
-    def erb(string, binding)
-      string
-    end
-
-    def allows_script?
-      true
-    end
-  end
-
-  class ERBSyntaxHighlightingRedcarpetTemplate < SyntaxHighlightingRedcarpetTemplate
-    def erb(string, binding)
-      ::ERB.new(string).result(binding)
-    end
-  end
-end
-
-Tilt.prefer(Tilt::SyntaxHighlightingRedcarpetTemplate, 'md')
-Tilt.prefer(Tilt::SyntaxHighlightingRedcarpetTemplate, 'markdown')
-Tilt.prefer(Tilt::ERBSyntaxHighlightingRedcarpetTemplate, 'md.erb')
-Tilt.prefer(Tilt::ERBSyntaxHighlightingRedcarpetTemplate, 'markdown.erb')
-
-
-if $0 == __FILE__
-
-markdown = <<-__
-* one
-* two
-* <%= :three %>
-* <%= @x %>
-
-```rb
-@a = 42
-yield
-```
-__
-
-template = Tilt['md.erb'].new{ markdown  }
-
-object = Object.new.instance_eval{ @x = :four; self }
-
-puts template.render(object)
-
-end

data/lib/ro/lock.rb

@@ -1,53 +0,0 @@
-module Ro
-  class Lock
-    def initialize(path)
-      @path = path.to_s
-      @fd = false
-    end
-
-    def lock(&block)
-      open!
-
-      if block
-        begin
-          lock!
-          block.call
-        ensure
-          unlock!
-        end
-      else
-        self
-      end
-    end
-
-    def open!
-      @fd ||= (
-        fd =
-          begin
-            open(@path, 'ab+')
-          rescue
-            unless test(?e, @path)
-              FileUtils.mkdir_p(@path)
-              FileUtils.touch(@path)
-            end
-
-            open(@path, 'ab+')
-          end
-
-        fd.close_on_exec = true
-
-        fd
-      )
-    end
-
-    def lock!
-      open!
-      @fd.flock File::LOCK_EX
-    end
-
-    def unlock!
-      open!
-      @fd.flock File::LOCK_UN
-    end
-  end
-end

data/lib/ro/node/list.rb

@@ -1,142 +0,0 @@
-module Ro
-  class Node
-    class List < ::Array
-      fattr :root
-      fattr :type
-      fattr :index
-
-      def initialize(*args, &block)
-        options = Map.options_for!(args)
-
-        root = args.shift || options[:root]
-        type = args.shift || options[:type]
-
-        @root = Root.new(root)
-        @type = type.nil? ? nil : String(type)
-        @index = {}
-
-        block.call(self) if block
-      end
-
-      def nodes
-        self
-      end
-
-      def load(path)
-        add( node = Node.new(path) )
-      end
-
-      def add(node)
-        return nil if node.nil?
-
-        unless index.has_key?(node.identifier)
-          push(node)
-          index[node.identifier] = node
-          node
-        else
-          false
-        end
-      end
-
-      def related(*args, &block)
-        related = List.new(root)
-
-        each do |node|
-          node.related(*args, &block).each do |related_node|
-            related.add(related_node)
-          end
-        end
-        
-        related
-      end
-
-      def [](*args, &block)
-        key = args.first
-
-        case key
-          when String, Symbol
-            if @type.nil?
-              type = key.to_s
-              list = select{|node| type == node._type}
-              list.type = type
-              list
-            else
-              id = Slug.for(key.to_s)
-              detect{|node| id == node.id}
-            end
-          else
-            super(*args, &block)
-        end
-      end
-
-      def select(*args, &block)
-        List.new(root){|list| list.replace(super)}
-      end
-
-      def where(*args, &block)
-        case
-          when !args.empty? && block
-            raise ArgumentError.new
-
-          when args.empty? && block
-            select{|node| node.instance_eval(&block)}
-
-          when !args.empty?
-            ids = args.flatten.compact.uniq.map{|arg| Slug.for(arg.to_s)}
-            index = ids.inject(Hash.new){|h,id| h.update(id => id)}
-            select{|node| index[node.id]}
-
-          else
-            raise ArgumentError.new
-        end
-      end
-
-      def find(*args, &block)
-        case
-          when !args.empty? && block
-            raise ArgumentError.new
-          when args.empty? && block
-            detect{|node| node.instance_eval(&block)}
-
-          when args.size == 1
-            id = args.first.to_s
-            detect{|node| node.id == id}
-
-          when args.size > 1
-            where(*args, &block)
-
-          else
-            raise ArgumentError.new
-        end
-      end
-
-      def identifier
-        [root, type].compact.join('/')
-      end
-
-      include Pagination
-
-      def method_missing(method, *args, &block)
-        Ro.log "Ro::List(#{ identifier })#method_missing(#{ method.inspect }, #{ args.inspect })"
-
-        if @type.nil?
-          type = method.to_s
-          list = self[type]
-          super unless list
-          list.empty? ? super : list
-        else
-          node = self[Slug.for(method, :join => '-')] || self[Slug.for(method, :join => '_')]
-          node.nil? ? super : node
-        end
-      end
-
-      def binding
-        Kernel.binding
-      end
-
-      def _binding
-        Kernel.binding
-      end
-    end
-  end
-end