infod 0.0.3.3 → 0.0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 06750f111d49bb2b62f28cd18bc35dd5212dc0ac
-  data.tar.gz: 7ee2db920696465b43201741aa28e6ecaf64af41
+  metadata.gz: 394fa91160ccafe206a32071d20edbaafbe1eef8
+  data.tar.gz: 5011996cc3fff07d31d2988b10226243082e668c
 SHA512:
-  metadata.gz: 03d0d7ae6b88af73a4d5054e2736764d46d5e3247284bcbda919c811182ab0bdbf4e2ef37ccd5fdd8228f4435f3bc6f23311f6f6ac41a9f70016338e4bc6a01c
-  data.tar.gz: ff95efae2b1690cd8f244360e903d1f9a7ea287a2450cdcb85e418b1f444eed54d9601819f4a266897ba0409711ad5af572f984f65a9b076395c2cf690a26cdb
+  metadata.gz: eb8da61e738b9efd9e8df67e0c904ccd0a9db0247b38594d2720b5740368da1702687a2d6589f3a3b6b767dd00c2f34794bdb741223ce82e2e78f934899d2388
+  data.tar.gz: cdc489d2660c7dfe8f44f9048dd0b1ba88267ba6484f3cd4d31daf58c4bbe85bdc7efaed742878f9bc893fa7b7bb2f745391d2668a2a85754d0a1d9d4e91d8d0

data/infod.rb

@@ -15,7 +15,7 @@ shellwords}.map{|r|require r}
 %w{
 constants
 lambda
-mime
+MIME
 404
 500
 grep
@@ -45,6 +45,7 @@ names
 POST
 rdf
 schema
+SPARQL
 text
 threads
 time

data/infod/404.rb

@@ -23,15 +23,12 @@ s[HTTP+'statusCodeValue'] = [404]
 
     [404,{'Content-Type'=> r.format},[e.render(r.format,g,r)]]}
 
-  F['/cache/GET'] = F[E404]
-
   fn 'view/404',->d,e{
     [H.css('/css/404'),{_: :style, c: "a {background-color:#{R.cs}}"},
      d.html]}
 
-  # a resource-placeholder graph
-  fn 'protograph/blank',->d,_,m{
-    m[d.uri] = {}
+  fn 'protograph/blank',->d,_,m{ # 404 is determined by #empty?
+    m[d.uri] = {} # insert a resource
     rand.to_s.h}
 
   def checkURIs
@@ -40,9 +37,11 @@ s[HTTP+'statusCodeValue'] = [404]
       puts c.join ' ' 
       c } # status, uri tuple
     puts "\n\n"
-    r.map{|c|
-      # show anomalies
+    r.map{|c| # inspect anomalies
       puts c.join(' ') unless c[0] == 200 }
   end
 
+  F['/cache/GET'] = F[E404]
+  F['/index/GET'] = F[E404]
+
 end

data/infod/500.rb

@@ -1,54 +1,18 @@
-#watch __FILE__
 class R
-  
-  Errors ||= {}
-
-  fn 'E500',->x,e{
-    stack = x.backtrace
-    $stderr.puts [500, e['REQUEST_URI'], x.class, x.message, stack[0]].join ' '
-
-    Errors[e['uri']] ||= {}
-    Errors[e['uri']][:time] = Time.now
-    Errors[e['uri']][:env] = [e, x.class.to_s, x.message, stack.join('<br>')]
 
+  fn 'E500',->x,e{ $stderr.puts [500, e['REQUEST_URI'], x.class, x.message].join ' '
     [500,{'Content-Type'=>'text/html'},
      [H[{_: :html,
-          c: [{_: :head,
-                c: [{_: :title, c: 500},(H.css '/css/500')]},
+          c: [{_: :head,c: [{_: :title, c: 500},(H.css '/css/500')]},
               {_: :body,
                 c: [{_: :h1, c: 500},
                     {_: :table,
                       c: [{_: :tr,c: [{_: :td, c: {_: :b, c: x.class}},{_: :td, class: :space},{_: :td, class: :message, c: x.message.hrefs}]},
-                          stack.map{|f| p = f.split /:/, 3
+                          x.backtrace.map{|f| p = f.split /:/, 3
                             {_: :tr,
                               c: [{_: :td, class: :path, c: p[0].abbrURI},
                                   {_: :td, class: :index, c: p[1]},
                                   {_: :td, class: :context, c: (p[2]||'').hrefs}].cr}}.cr]}]}]}]]]}
 
-  F['/500/GET'] = ->e,r{
-    body = H [Errors.sort_by{|u,r|r[:time]}.reverse.html, H.css('/css/500')]
-    [200, {'Content-Type'=>'text/html; charset=utf-8'}, [body]]}
-
-  F['view/'+COGS+'Exception']=->e,r{
-    e.values.map{|e|
-      {style: 'border-radius:1em;background-color:#333;color:#eee;float:left;max-width:42em',
-        c: [{_: :h2, c: "<b style='background-color:#f00'>&#0191;</b>"+(e[Title]||[]).to_s},
-            e[Content]||''
-           ]}}}
-
-  # filesystem takes priority over this if it's found
-  fn '/css/500.css/GET',->e,r{
-    [200,{'Content-Type'=>'text/css'},["
-body {margin:0; font-family: sans-serif; background-color:#fff; color:#000}
-h1 {padding:.2em; background-color:#f00; color:#fff; margin:0}
-div {display:inline}
-table {border-spacing:0;margin:0}
-b {background-color:#eee;color:#500;padding:.1em .3em .1em .3em}
-.frag {font-weight:bold; color:#000; background-color:#{R.cs}}
-td.space {background-color:#ddd}
-td.message {background-color:#009;color:#fff}
-td.path {text-align:right}
-td.index {text-align:right;border-color:#000;border-width:0 0 .1em 0;border-style:dotted;background-color:#ddd;color:#000}
-td.context {border-color:#ddd;border-width:0 0 .1em 0;border-style:dotted;padding:.15em}"]]}
-
 end
+

data/infod/GET.rb

@@ -14,7 +14,7 @@ class R
       a = @r.accept.values.flatten
       accepted = a.empty? || (a.member? file.mimeP) || (a.member? '*/*')
       (!accepted || MIMEcook[file.mimeP] || @r.q.has_key?('view')) ?
-       resource : (file.env @r).getFile
+       resource : (file.env @r).fileGET
 
     else
       resource
@@ -29,13 +29,13 @@ class R
     [200,{},[]]
   end
 
-  def getFile
+  def fileGET
     @r['ETag'] = [m,size].h
     maybeSend mimeP,->{self}
   end
 
   def resource
-    # bubble up site then global tree until handled (false return-value to pass)
+    # bubble up full-hostname then path tree until handled
     pathSegment.do{|path|
       lambdas = path.cascade.map{|p| p.uri.t + 'GET' }
       ['http://'+@r['SERVER_NAME'],""].map{|h| lambdas.map{|p|
@@ -48,31 +48,30 @@ class R
 
   def response
 
-    m = {}
+    m = {} # TODO request-model as RDF::Graph, benchmark vs our pickle-able JSON graphs, + write persistable RDF::Repository class of similar performance
 
-    # graph-identity (model)
-    g = @r.q['graph']
+    # Model
+    g = @r.q['graph'] # model identity
     graphID = (g && F['protograph/' + g] || F['protograph/'])[self,@r.q,m]
 
-    return F[E404][self,@r] if m.empty?
+    return F[E404][self,@r] if m.empty? # protograph empty - nothing found
 
-    # response-identity (view)
+    # View
     @r['ETag'] ||= [@r.q['view'].do{|v|F['view/' + v] && v}, graphID, @r.format, Watch].h
 
     maybeSend @r.format, ->{
-
       r = R '/cache/view/' + @r['ETag'].dive
-      if r.e # exists?
+      if r.e # view exists?
         r
       else
         c = R '/cache/model/' + graphID.dive
-        if c.e # exists?
+        if c.e # model exists?
           m = c.r true
         else
-          (g && F['graph/' + g] || F['graph/'])[self, @r.q,m] # construct
-          c.w m,true # cache
+          (g && F['graph/' + g] || F['graph/'])[self, @r.q,m]
+          c.w m,true # model -> cache
         end
-        r.w render @r.format, m, @r # construct -> cache
+        r.w render @r.format, m, @r # view -> cache
       end }
   end
 
@@ -98,13 +97,13 @@ class R
       [304,{},[]]  # client has response
   end
 
-  # user-patchable default handler - use index.html or defer to internal default-handler #response
+  # user-patchable root-level handler - index.html or continue to default-handler
   fn '/GET',->e,r{
     x = 'index.html'
     i = [e,e.pathSegment].compact.map{|e|e.as x}.find &:e
     if i && !r['REQUEST_URI'].match(/\?/)
       if e.uri[-1] == '/' # inside dir?
-        i.env(r).getFile  # show index
+        i.env(r).fileGET  # show index
       else                # descend into dir
         [301, {Location: e.uri.t}, []]
       end

data/infod/HTTP.rb

@@ -1,9 +1,13 @@
 #watch __FILE__
 class R
 
+  def env r=nil
+    r ? (@r = r; self) : @r
+  end
+
   def R.call e
     e.extend Th # HTTP utility functions
-    dev # see if watched files were changed
+    dev         # watched files changed?
     e['HTTP_X_FORWARDED_HOST'].do{|h| e['SERVER_NAME'] = h }
     path = CGI.unescape e['REQUEST_PATH'].force_encoding('UTF-8').gsub '+','%2B'
     resource = R['http://'+e['SERVER_NAME']+path]

data/infod/{mime.rb → MIME.rb}

@@ -137,9 +137,7 @@ class R
 
   # prefer a view even if requested file exists
   MIMEcook={
-    'application/atom+xml' => true,
     'application/markdown' => true,
-    'application/json+rdf' => true,
     'application/org' => true,
     'application/postscript' => true,
     'application/textile' => true,

data/infod/POST.rb

@@ -2,42 +2,43 @@
 class R
 
   def POST
-    # custom handler lookup cascade
-    pathSegment.do{|path|
+    pathSegment.do{|path| # handler cascade
       lambdas = path.cascade.map{|p| p.uri.t + 'POST' }
       ['http://'+@r['SERVER_NAME'],""].map{|h| lambdas.map{|p|
-          F[h + p].do{|fn| fn[self,@r].do{|r|
-              $stdout.puts [r[0],'http://'+@r['SERVER_NAME']+@r['REQUEST_URI'],@r['HTTP_USER_AGENT'],@r['HTTP_REFERER'],@r.format].join ' '
-              return r
-            }}}}}
-    basicPOST
-  end
-  def basicPOST
-    return [303,{'Location'=>uri},[]]
+          F[h + p].do{|fn|fn[self,@r].do{|r| return r }}}}}
+
     case @r['CONTENT_TYPE']
     when /^application\/x-www-form-urlencoded/
-      changed = false
-      (Rack::Request.new @r).params.map{|k,v| s, p, tripleA = JSON.parse CGI.unescape k
-        s = s.R
-       pp = s.predicatePath p
-        o = v.match(/\A(\/|http)[\S]+\Z/) ? v.R : F['cleanHTML'][v]
-        tripleB = pp.objectPath(o)[0]
-        if tripleA.to_s != tripleB.to_s
-          tripleA && tripleA.R.do{|t| t.delete if t.e }
-          s[p] = o unless o.class==String && o.empty?
+      formPOST
+    end
+  end
+
+  def formPOST
+    changed = false
+    params = (Rack::Request.new @r).params
+    params.map{|k,v|
+      s, p, tripleX = JSON.parse CGI.unescape k rescue JSON::ParserError
+      if s # parse successful?
+        s = s.R # subject URI
+        pp = s.predicatePath p # s+p path
+        o = v.match(/\A(\/|http)[\S]+\Z/) ? v.R : F['cleanHTML'][v] # HTML cleanup
+        tripleY = pp.objectPath(o)[0]   # editable triple
+        if tripleX.to_s != tripleY.to_s # changed?
+          tripleX && tripleX.R.do{|t| t.delete if t.e } # remove triple
+          s[p] = o unless o.class==String && o.empty?   # add triple
           changed = true
-        end}
-      if changed
-        g = {}
-        fromStream g, :triplrDoc
-        if g.empty? # no triples left
-          ef.delete
-        else        # snapshot to graph-doc
-          ef.w g, true
         end
+      end}
+    if changed # update doc
+      g = {} # triples -> graph
+      fromStream g, :triplrDoc
+      if g.empty? # 0 triples
+        ef.delete
+      else # graph -> doc #TODO write doc-per-version and symlink current (optional history)
+        ef.w g, true
       end
     end
-    [303,{'Location'=>uri+'?graph=edit'},[]]
+    [303,{'Location'=>uri+'?graph=edit'+(params['mono'] ? '&mono' : '')},[]]
   end
 
 end

data/infod/SPARQL.rb

@@ -0,0 +1,6 @@
+#watch __FILE__
+class R
+
+#  TODO expose fs.rb as an RDF::Queryable interface - maybe RDF::Repository too
+
+end

data/infod/WebID.rb

@@ -0,0 +1,3 @@
+class R
+
+end

data/infod/blog.rb

@@ -1,20 +1,29 @@
 #watch __FILE__
 class R
 
+  # traverse collection of blog-posts
+  F['/blog/GET'] = -> d,e {
+    e.q['set'] = 'depth' # post-range in date-order
+    e.q['local'] = true  # hostname-specific paths
+    e.q['c'] = 8         # count
+    R['http://'+e['SERVER_NAME']+'/time'].env(e).response}
+
+  # decode POSTed title, mint derived-URI, set title+type properties, continue to editor
   F['/blog/post/POST'] = -> d,e {
-    name = URI.escape (Rack::Request.new d.env).params['name'].gsub /[?#\s\/]/,'_'
-    doc = 'http://'+e['SERVER_NAME']+Time.now.strftime('/%Y/%m/')+name
-    post = doc.R.a '#'
-    post[Type] = R[SIOCt+'BlogPost']
-    post[Title] = name
-    edit = "?prototype=sioct:BlogPost&graph=edit"
-    [303,{'Location' => doc + edit},[]]}
+    host = 'http://' + e['SERVER_NAME']
+    title = (Rack::Request.new d.env).params['title']
+    base = R[host+Time.now.strftime('/%Y/%m/%d/')+URI.escape(title.gsub /[?#\s\/]/,'_')] # doc 
+    post = base.a '#'                                                              # editable resource
+    post[Type] = R[SIOCt+'BlogPost']; post[Title] = title                          # add type-tag & title
+    base.ef.ln_s R[host + '/time/' + Time.now.iso8601[0..18].gsub('-','/') + '.e'] # add to datetime-index
+    [303,{'Location' => (base+"?prototype=sioct:BlogPost&graph=edit&mono").uri},[]]}
 
+  # POST post-title to /blog/post
   F['/blog/post/GET'] = -> d,e {
     [200,{'Content-Type'=>'text/html'},
-     [H(['name',
+     [H(['title',
          {_: :form, method: :POST,
-           c: [{_: :input, name: :name, style: "font-size:1.6em;width:48ex"},
+           c: [{_: :input, name: :title, style: "font-size:1.6em;width:48ex"},
                {_: :input, type: :submit, value: ' go '}
               ]}])]]}
 
@@ -25,11 +34,11 @@ class R
       case u # match against URIs for customized view
       when /artery.wbur/ # compact whitespace a bit
         r[Content] = {class: :WBUR, c: [{_: :style, c: ".WBUR p {margin:0}"},r[Content]]}
-        F['view/base'][{u => r},e,false]        
+        F['view/base'][{u => r},e]
 
       when /boston\.com/ # crop sharebuttons
        (Nokogiri::HTML.parse r[Content][0]).css('p')[0].do{|p|r[Content]=p.inner_html}
-        F['view/base'][{u => r},e,false]
+        F['view/base'][{u => r},e]
 
       when /flickr/
         r[Content]
@@ -44,8 +53,21 @@ class R
                c: [{_: :img, src: '/logos/uhub.png',style: 'position:absolute;top:-93px'},
                    {_: :h2, style: 'color:#000;margin:0',c: r[Title]}]},c.to_s],
           style: 'float:left;max-width:40em;position:relative;background-color:#fff;border-color:#eee;margin-top:93px;margin-right:.3em;padding-top:0;border-style:dotted;border-width:.3em;border-radius:0 .8em .8em .8em'}
-      else
-        F['view/base'][{u => r},e,false]
+      else # host matches current
+        if u.index('http://'+e['SERVER_NAME']) == 0
+          [{_: :a, href: u, c: {_: :h1, c: r[Title]}},
+           {_: :p, c: r[Content]},
+#           F['view/comment'][{u => r},e]
+          ]
+        else # non-local (imported) host
+          F['view/base'][{u => r},e]
+        end
       end}}
 
+  F['view/comment'] = -> g,e {
+    g.map{|u,r|
+      "comment"
+    }
+  }
+
 end

data/infod/constants.rb

@@ -1,4 +1,4 @@
-class R
+class R < RDF::URI
 
   FSbase = `pwd`.chomp ;  BaseLen = FSbase.size
 
@@ -52,6 +52,4 @@ class R
     "stat" => Stat,
   }
 
-  attr_reader :uri
-
 end

data/infod/edit.rb

@@ -28,10 +28,9 @@ class R
     puts "graph.edit #{e}"
     e.fromStream g, :triplrDoc} # add fs-sourced triples
     
-=begin HTML <form> RDF editor
-      arg
-      prototype - initialize fields for a resource-type
-      predicate - initialize field for a particular predicate
+=begin HTML <form> triple-editor
+  @prototype bundle of fields for a type
+  @predicate add field for a particular predicate
 =end
   fn 'view/edit',->g,e{
 
@@ -54,6 +53,7 @@ class R
     e.q['prototype'].do{|pr| pr = pr.expand
       Prototypes[pr].do{|v|ps.concat v }} # prototype imports
     e.q['predicate'].do{|p|ps.push p }    # explicit predicate
+    mono = e.q.has_key? 'mono' # 1:1 predicate->object
 
     [H.css('/css/html'),
      {_: :form, name: :editor, method: :POST, action: e['REQUEST_PATH'],
@@ -68,10 +68,12 @@ class R
                      {_: :tr,
                        c: [{_: :td, class: :key, c: {_: :a, title: p, href: p, c: p.abbrURI}}, # property
                            {_: :td,
-                             c: [r[p].do{|o|                            # objects
-                                   (o.class == Array ? o : [o]).map{|o| # each object
-                                     triple[s,p,o]}},                   # existing triples
-                                 triple[s,p,nil]]}]}}]}},                # new triple
+                             c: [r[p].do{|o|              # object?
+                                   o.justArray.map{|o|    # each object
+                                     triple[s,p,o]}},     # extant triples
+                                 (triple[s,p,nil] unless r[p] && mono) # add triple
+                                ]}]}}]}},
+          ({_: :input, type: :hidden, name: :mono, value: :true} if mono),
            {_: :input, type: :submit, value: 'save'}]}]}
 
   # select a property to edit

data/infod/facets.rb

@@ -17,7 +17,7 @@ class R
     # facet stats
     m.map{|s,r| a.map{|p,_|
         r[p].do{|o|
-          (o.class==Array ? o : [o]).map{|o|
+            o.justArray.map{|o|
             a[p][o]=(a[p][o]||0)+1}}}}
 
 
@@ -31,7 +31,7 @@ class R
       m.map{|u,r| # each resource
         a.map{|p,_| # each facet
           [n[p], r[p].do{|o| # value
-             (o.class==Array ? o : [o]).map{|o|
+               o.justArray.map{|o|
                n[o.to_s] # identifier
              }}].join ' '
         }.do{|f|