ro 1.1.1 → 1.2.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YmViOTZiYmVkMjE5NjliNmRhZDlhYzBlN2VkYWQ3N2QxNDg2MjU1Yg==
+    NjU3NjMzOGVkNmQyZDFmNzk0MjBlOTc1MjRiYTFjYzhhOTFjM2E3NA==
   data.tar.gz: !binary |-
-    ZGY4OGU3Yzc2Nzg5NTllZDIxMzllNjkzN2ExNDQyMDFhM2Q1ZWI0Yw==
+    ZWNmMmIyZjcwNTJkYmU0ZDJkZTYwZGYwYjE4MWEyZDdiMmM5Y2ZkMQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    Y2U4MjU2MDBjMGI4MGI3ODBiOTUwZTYyZTUyOGJiODBkNWMxNTYwZTMxOTBh
-    YjAzNTVhNjc5ODE3MzNiYWY1MzMwNWU2YjU0MGI5MmM2MGI5Y2IwMjU3MDM5
-    MjMwYjFlZmJjNzA5MmEwZGEwYjI4NzM3MWI3MjRmMTA4ZmJiNDE=
+    NjUxM2JkYjg5OTMxODM3ZGVmYjBhYjgwOTc3ZTFlYjY4N2FiNTQyMDc3ZDUz
+    M2FmNWQxMTMzYjk4NjlhYzIxYTcwYTQ3MTM2ODA0NDEwNzY2YjI2YWJiM2Ey
+    MzQzMTI5ZTE2MjZhMTE0Mjg0ZTNiZWY3OTdiNWYzYzk4ODA4MDA=
   data.tar.gz: !binary |-
-    MDg3M2FiOTRiMTlmZGMzNmJkNzI3MWFjNTE1YjkyMzJmN2U3NTVjMGQxMjc3
-    MjYxYjM1OGM3Yzk2YmVmZTc4NDlkMjdiNjZkMGVkNjRmYTUwYmJmOTk5YzE2
-    NTJmY2NjYzNiZTcyMDQ4NTc3NTY5ZTcxYzZlYjU3ZDdkNTQ5Njk=
+    NWRkODVlNDYzY2I4NzA4N2Q1ZDM5MTNhYzc1OTU1YWE5MjQ5NWMxZGUwOTZk
+    YzA0MmJhNjdmNjg1ZjBhNTIxN2QwNzA1M2Q4ZWZkMmQ3ZDJlYjFmYmYwZjA4
+    M2VmZDlkZjY2ZWMyMTBhYjdlYzI0NTU2NWE5MDg5MTE4OTIwYmY=

data/README.md

@@ -5,7 +5,7 @@ ro
 
 
 TL;DR
---------
+-----
 
 <pre>
 
@@ -139,6 +139,31 @@ INSTALL
 gem install ro
 
 
+CONFIG
+------
+
+if you are using the url methods you'll need to make sure your application can
+route to the assets.  by default ro assumes that the urls it generates are
+routeable under '/ro' so it is up to you to make sure this works.
+
+for a rails app this might mean writing a 'RoController' or, more simply, just
+putting your ro data in ./public/ro.
+
+for a middleman app this might mean putting your ro data in ./source/ro.
+
+if you choose a non-standard approach you'll need to
+
+```
+
+  Ro.route = '/my-custom-route'
+
+
+```
+
+in all cases ro urls will be prefixed by the route, so be sure that this prefix
+is either automatically, or manually, exposed.
+
+
 DOCS
 ----
 

data/Rakefile

@@ -84,7 +84,7 @@ task :gemspec do
   lib         = This.lib
   object      = This.object
   version     = This.version
-  files       = shiteless[Dir::glob("**/**")]
+  files       = shiteless[Dir::glob("**/**")].select{|path| test(?f, path)}
   executables = shiteless[Dir::glob("bin/*")].map{|exe| File.basename(exe)}
   #has_rdoc    = true #File.exist?('doc')
   test_files  = test(?e, "test/#{ lib }.rb") ? "test/#{ lib }.rb" : nil

data/TODO.md

@@ -0,0 +1,50 @@
+todo:
+
+  Model[id]
+  Model.select
+  Model.where
+
+  - reconsider using active_model...
+
+  - with ro, do we/should we need to expand assets?
+    - posts
+    -   body.md -> html -> expand_asset_urls?
+
+  - https://github.com/rails/rails/blob/master/activemodel/lib/active_model/model.rb
+
+  - track where shit comes from...
+
+  - custom ui better?
+    - chiclets
+    - posts
+
+done:
+
+- expand relative asset links in html
+
+- patch based transactions
+
+  - http://ariejan.net/2009/10/26/how-to-create-and-apply-a-patch-with-git/
+
+  - git checkout -b test-branch
+  - add, commit, etc
+    - add assets last
+
+  - git format-patch master --stdout > p.patch
+
+  - actor.date.uuid
+
+  - 
+    a:~/git/ahoward/ro $ git apply --stat p.patch
+     tmp/coat.zip |  Bin
+     tmp/a.txt    |    1 +
+     2 files changed, 1 insertion(+)
+
+  - git apply --check p.patch
+
+  - git am --signoff < fix_empty_poster.patch
+
+  - iff fail: sorry, your edits conflict with another user!
+    - because they need to review new content ;-)
+
+  - git branch -D test-branch

data/bin/ro

@@ -2,14 +2,24 @@
 
 Main {
 
-  option('--root', '-r'){
-    argument :required
+  argument('root'){
+    optional
   }
 
+  def run
+    help!
+  end
+
   mode(:console){
     def run
-      if params['root'].given? 
+      if params['root'].given?
         Ro.root = params['root'].value 
+      else
+        if ENV['RO_ROOT']
+          Ro.root = ENV['RO_ROOT']
+        else
+          Ro.root = './ro'
+        end
       end
 
       basename = File.basename(Ro.root) 

data/lib/ro.rb

@@ -10,7 +10,7 @@
 
 #
   module Ro
-    Version = '1.1.1' unless defined?(Version)
+    Version = '1.2.0' unless defined?(Version)
 
     def version
       Ro::Version
@@ -20,17 +20,13 @@
       {
         'map'               => [ 'map'               , ' >= 6.5.1' ] ,
         'fattr'             => [ 'fattr'             , ' >= 2.2.1' ] ,
-        'tilt'              => [ 'tilt'              , ' >= 1.4.1' ] ,
+        'tilt'              => [ 'tilt'              , ' >= 1.3.1' ] ,
         'pygments'          => [ 'pygments.rb'       , ' >= 0.5.0' ] ,
         'coerce'            => [ 'coerce'            , ' >= 0.0.4' ] ,
         'stringex'          => [ 'stringex'          , ' >= 2.1.0' ] ,
-      # 'rails'             => [ 'rails'             , ' >= 3.1'   ] ,
-      # 'tagz'              => [ 'tagz'              , ' >= 9.9.2' ] ,
-      # 'multi_json'        => [ 'multi_json'        , ' >= 1.0.3' ] ,
-      # 'uuidtools'         => [ 'uuidtools'         , ' >= 2.1.2' ] ,
-      # 'wrap'              => [ 'wrap'              , ' >= 1.5.0' ] ,
-      # 'rails_current'     => [ 'rails_current'     , ' >= 1.8.0' ] ,
-      # 'rails_errors2html' => [ 'rails_errors2html' , ' >= 1.3.0' ] ,
+        'systemu'           => [ 'systemu'           , ' >= 2.5.2' ] ,
+        'nokogiri'          => [ 'nokogiri'          , ' >= 1.6.1' ] , 
+        'main'              => [ 'main'              , ' >= 5.2.0' ] , 
       }
     end
 
@@ -80,22 +76,26 @@
 #
 
   module Ro
-    Fattr(:root){
-      Root.new(
-        case
-          when defined?(Rails.root)
-            root = Rails.root.to_s
-            File.join(root, 'public', 'ro')
+    def Ro.default_root
+      [ ENV['RO_ROOT'], "./public/ro", "./source/ro" ].compact.detect{|d| test(?d, d)} || "./ro"
+    end
 
-          when defined?(Middleman::Application)
-            root = Middleman::Application.server.root.to_s
-            File.join(root, 'source', 'ro')
+    def Ro.root=(root)
+      @root = Root.new(root.to_s)
+    end
 
-          else
-            ENV['RO_ROOT'] || "./ro"
-        end
-      )
-    }
+    def Ro.root(*args)
+      Ro.root = args.first unless args.empty?
+      @root ||= Root.new(Ro.default_root)
+    end
+
+    def Ro.git
+      root.git
+    end
+
+    def Ro.patch(*args, &block)
+      git.patch(*args, &block)
+    end
 
     Fattr(:cache){
       Cache.new
@@ -105,7 +105,7 @@
       nil
     }
 
-    Fattr(:mount){
+    Fattr(:route){
       '/ro'
     }
 
@@ -155,14 +155,18 @@
 
     def Ro.slug_for(*args, &block)
       options = Map.options_for!(args)
-      options[:join] = '-'
+      unless options.has_key?(:join)
+        options[:join] = '-'
+      end
       args.push(options)
       Slug.for(*args, &block)
     end
 
     def Ro.name_for(*args, &block)
       options = Map.options_for!(args)
-      options[:join] = '_'
+      unless options.has_key?(:join)
+        options[:join] = '_'
+      end
       args.push(options)
       Slug.for(*args, &block)
     end
@@ -191,6 +195,49 @@
       Template.render_source(*args, &block)
     end
 
+    def Ro.expand_asset_urls(html, node)
+      begin
+        accurate_expand_asset_urls(html, node)
+      rescue Object
+        sloppy_expand_asset_urls(html, node)
+      end
+    end
+
+    def Ro.accurate_expand_asset_urls(html, node)
+      doc = Nokogiri::HTML(html)
+
+      doc.traverse do |element|
+        if element.respond_to?(:attributes)
+          element.attributes.each do |attr, attribute|
+            value = attribute.value
+            if value =~ %r{(?:./)?assets/(.+)$}
+              begin
+                base, ext = $1.split('.', 2)
+                url = node.url_for(base)
+                attribute.value = url
+              rescue Object
+                next
+              end
+            end
+          end
+        end
+      end
+
+      doc.xpath('//body').inner_html.strip
+    end
+
+    def Ro.sloppy_expand_asset_urls(html, node)
+      html.to_s.gsub(%r{['"]assets/([^'"]+)['"]}) do |match|
+        base, ext = $1.split('.', 2)
+
+        begin
+          node.url_for(base).inspect
+        rescue Object
+          match
+        end
+      end
+    end
+
     def Ro.paths_for(*args)
       path = args.flatten.compact.join('/')
       path.gsub!(%r|[.]+/|, '/')
@@ -262,6 +309,8 @@
     blankslate.rb
 
     root.rb
+    lock.rb
+    git.rb
 
     cache.rb
 

data/lib/ro/cache.rb

@@ -1,12 +1,13 @@
 module Ro
-  class Cache < ::Hash
+  class Cache < ::Map
     def write(key, value)
-      self[key] = value
+      invalidate(key)
+      set(key => value)
     end
 
     def read(key, &block)
-      if has_key?(key)
-        self[key]
+      if has?(key)
+        get(key)
       else
         if block
           value = block.call
@@ -16,5 +17,10 @@ module Ro
         end
       end
     end
+
+    def invalidate(key)
+      prefix = Array(key).dup.tap{|array| array.pop}
+      set(prefix, {})
+    end
   end
 end

data/lib/ro/git.rb

@@ -0,0 +1,359 @@
+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 }"
+
+      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
+              #
+                spawn("git add . --all", :raise => true)
+
+              # commit if anything changed
+              #
+                changes_to_apply =
+                  spawn("git commit -am #{ 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)
+
+                    status, stdout, stderr =
+                      spawn("git am --signoff --3way", :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)
+
+              # get changes
+              #
+                trying('to pull'){ spawn("git pull") }
+
+              # nuke the tmp branch
+              #
+                spawn("git branch -D #{ branch.inspect }")
+              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
+        #
+          git_root = `git rev-parse --git-dir`.strip
+
+          if git_root.empty?
+            git_root = '.'
+          end
+
+          dot_git = File.expand_path(File.join(git_root, '.git'))
+
+          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