fabulator-exhibit 0.0.1

data/README.rdoc

@@ -0,0 +1,79 @@
+= fabulator-exhibit
+
+* http://github.com/jgsmith/ruby-fabulator-exhibit
+
+== DESCRIPTION:
+
+Fabulator engine extension for creating Exhibit data sources.
+
+Namespace: http://dh.tamu.edu/ns/fabulator/exhibit/1.0#
+
+See http://www.simile-widgets.org/exhibit/ for more information
+on Exhibit 
+
+== FEATURES/PROBLEMS:
+
+== SYNOPSIS:
+
+=== In Ruby
+
+ require 'fabulator/exhibit'
+
+=== In Fabulator applications
+
+ <ex:database ex:database="data">
+   <ex:item ex:id="'id'" ex:label="'label'" ex:type="ItemType">
+     <ex:value ex:name="key" f:select="'value'" />
+   </ex:item>
+ </ex:database>
+
+== REQUIREMENTS:
+
+The uuid gem is required to autogenerate ids.
+
+This Fabulator extension provides to an Exhibit-style database, but does
+not provide actual storage.  The embedding framework will need to define
+several functions:
+
+=== Fabulator::Exhibit::Action::Lib.fetch_database(name)
+
+This function should return the Exhibit database.  It needs to look like
+the following data structure:
+
+  {
+     :types => { },
+     :properties => { },
+     :items => { }
+  }
+
+=== Fabulator::Exhibit::Action::Lib.store_database(name, data) 
+
+This function should store the data for later retrieval.  The data is provided
+in the same format it is returned by the fetch_database function.
+
+== INSTALL:
+
+* sudo gem install fabulator-exhibit
+
+== LICENSE:
+
+Copyright (c) 2010 Texas A&M University
+
+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/VERSION

@@ -0,0 +1 @@
+0.0.1

data/features/simple-database.feature

@@ -0,0 +1,25 @@
+Feature: Simple database items
+
+  Scenario: simple database with one item
+    Given the statemachine
+      """
+        <f:application xmlns:f="http://dh.tamu.edu/ns/fabulator/1.0#" 
+           xmlns:ex="http://dh.tamu.edu/ns/fabulator/exhibit/1.0#"
+           ex:database="test"
+        >
+          <ex:database>
+            <ex:item ex:id="'foo'" ex:type="fooType" ex:label="'fooLabel'">
+              <ex:value ex:name="bar" f:select="'baz'" />
+            </ex:item>
+          </ex:database>
+          <ex:database>
+            <f:value f:path="/f" f:select="ex:item('foo')" />
+          </ex:database>
+        </f:application>
+      """
+     And using the 'test' database
+    Then there should be 1 item
+     And the item 'foo' should have type 'fooType'
+     And the item 'foo' should have the label 'fooLabel'
+     And the item 'foo' should have the property 'bar' as 'baz'
+     And the expression (/f/bar) should equal ['baz']

data/features/step_definitions/exhibit_steps.rb

@@ -0,0 +1,24 @@
+Given /the '(.*)' database/ do |n|
+  @exhibit_db_nom = n
+end
+
+Then /there should be (\d+) items?/ do |n|
+  db = Fabulator::Exhibit::Actions::Lib.fetch_database(@exhibit_db_nom)
+  db[:items].size.should == n.to_i
+end
+
+Then /^the item '(.*)' should have type '(.+)'$/ do |id, type|
+  db = Fabulator::Exhibit::Actions::Lib.fetch_database(@exhibit_db_nom)
+  db[:items][id]['type'].should == type
+end
+
+Then /^the item '(.*)' should have the label '(.*)'$/ do |id, label|
+  db = Fabulator::Exhibit::Actions::Lib.fetch_database(@exhibit_db_nom)
+  db[:items][id]['label'].should == label
+end
+
+Then /^the item '(.*)' should have the property '(.*)' as '(.*)'$/ do |id, prop_name, prop_value|
+  db = Fabulator::Exhibit::Actions::Lib.fetch_database(@exhibit_db_nom)
+  db[:items][id][prop_name].should == prop_value
+end
+

data/features/step_definitions/expression_steps.rb

@@ -0,0 +1,104 @@
+require 'yaml'
+
+Transform /^(expression|context) \((.*)\)$/ do |n, arg|
+  @namespaces ||= { }
+  @parser ||= Fabulator::Expr::Parser.new
+  @parser.parse(arg, @context)
+end
+
+Transform /^\[(.*)\]$/ do |arg|
+  @parser ||= Fabulator::Expr::Parser.new
+  @parser.parse(arg, @context)
+end
+
+Transform /^(\d+)$/ do |arg|
+  arg.to_i
+end
+
+Given 'a context' do
+  @roots ||= { }
+  @data ||= Fabulator::Expr::Node.new('data', @roots, nil, [])
+  @roots['data'] ||= @data
+  @context ||= Fabulator::Expr::Context.new
+  @context.root = @data
+  @parser ||= Fabulator::Expr::Parser.new
+end
+
+Given /the prefix (\S+) as "([^"]+)"/ do |p,h|
+  @context ||= Fabulator::Expr::Context.new
+  @context.set_ns(p, h)
+end
+
+Given /that (\[.*\]) is set to (\[.*\])/ do |l,r|
+  @context.set_value(l, r)
+end
+
+When /I run the (expression \(.*\)) in the (context \(.*\))/ do |exp, cp|
+  @expr = exp
+  if cp.nil? || cp == ''
+    @result = []
+    @cp = @context.root
+  else
+    @cp = cp.run(@context).first || @context.root
+    @result = @expr.run(@context.with_root(@cp))
+  end
+end
+
+When /I run the (expression \(.*\))/ do |exp|
+  ## assume '/' as the context here
+  @expr = exp
+  @cp = @data
+  #puts YAML::dump(@expr)
+  @result = @expr.run(@context.with_root(@cp))
+  #puts YAML::dump(@result)
+end
+
+When /I unify the types? (.*)/ do |ts|
+  types = ts.split(/\s*,\s*/)
+  typea = types.collect { |t|
+      pn = t.split(/:/, 2)
+      [ @context.get_ns(pn[0]), pn[1] ]
+    }
+  @type_result = Fabulator::ActionLib.unify_types(
+    types.collect { |t|
+      pn = t.split(/:/, 2)
+      [ @context.get_ns(pn[0]), pn[1] ]
+    }
+  )
+end
+
+Then /I should get the type (.*)/ do |t|
+  pn = t.split(/:/, 2)
+  @type_result[0].should == @context.get_ns(pn[0])
+  @type_result[1].should == pn[1]
+end
+
+Then /I should get (\d+) items?/ do |count|
+  @result.length.should == count
+end
+
+Then /item (\d+) should be (\[.*\])/ do |i,t|
+  test = t.run(@context.with_root(@cp)).first
+   #puts "Result: #{@result[i.to_i].to_s.class.to_s}"
+  @result[i.to_i].to_s.should == test.to_s
+end
+
+Then /item (\d+) should be false/ do |i|
+  (!!@result[i.to_i].value).should == false
+end
+
+Then /item (\d+) should be true/ do |i|
+  (!!@result[i.to_i].value).should == true
+end
+
+Then /the (expression \(.*\)) should equal (\[.*\])/ do |x, y|
+  a = x.run(@context)
+  b = y.run(@context)
+  #puts YAML::dump(a)
+  #puts YAML::dump(b)
+  a.first.value.should == b.first.value
+end
+
+Then /the (expression \(.*\)) should be nil/ do |x|
+  x.run(@context).first.should == nil
+end

data/features/step_definitions/xml_steps.rb

@@ -0,0 +1,31 @@
+Given /the statemachine/ do |doc_xml|
+  doc = LibXML::XML::Document.string doc_xml
+
+  @roots ||= { }
+  @namespaces ||= { }
+  @data ||= Fabulator::Expr::Node.new('data', @roots, nil, [])
+  @roots['data'] ||= @data
+  @context ||= Fabulator::Expr::Context.new
+  @context.root = @data
+
+  @parser ||= Fabulator::Expr::Parser.new
+  if @sm.nil?
+    @sm = Fabulator::Core::StateMachine.new.compile_xml(doc, @context)
+  else
+    @sm.compile_xml(doc, @context)
+  end
+  @sm.init_context(@context)
+end
+
+When /I run it with the following params:/ do |param_table|
+  params = { }
+  param_table.hashes.each do |hash|
+    params[hash['key']] = hash['value']
+  end
+  @sm.run(params)
+  #puts YAML::dump(@sm)
+end
+
+Then /it should be in the '(.*)' state/ do |s|
+  @sm.state.should == s
+end

data/features/support/env.rb

@@ -0,0 +1,21 @@
+# This file makes it possible to install RubyCAS-Client as a Rails plugin.
+
+$: << File.expand_path(File.dirname(__FILE__))+'/../../lib'
+$: << File.expand_path(File.dirname(__FILE__))+'/../../../fabulator/lib'
+
+require 'fabulator'
+require 'fabulator/exhibit'
+require 'spec/expectations'
+require 'xml/libxml'
+
+Fabulator::Exhibit::Actions::Lib.class_eval do
+  def self.fetch_database(nom)
+    @@dbs ||= { }
+    @@dbs[nom] ||= { :types => {}, :items => {}, :properties => {} }
+    @@dbs[nom]
+  end
+
+  def self.store_database(nom, data)
+    @@dbs[nom] = data
+  end
+end

data/lib/fabulator/exhibit.rb

@@ -0,0 +1,2 @@
+require 'fabulator/exhibit/actions'
+require 'fabulator/exhibit/version'

data/lib/fabulator/exhibit/actions.rb

@@ -0,0 +1,124 @@
+
+module Fabulator
+  EXHIBIT_NS = "http://dh.tamu.edu/ns/fabulator/exhibit/1.0#"
+
+require 'fabulator/exhibit/actions/item'
+require 'fabulator/exhibit/actions/property'
+require 'fabulator/exhibit/actions/type'
+require 'fabulator/exhibit/actions/value'
+
+  module Exhibit
+    module Actions
+      class Lib
+        include Fabulator::ActionLib
+
+        @@databases = { }
+
+        register_namespace EXHIBIT_NS
+
+        action 'database', Database
+        action 'item', Item
+        action 'value', Value
+        action 'property', Property
+        action 'type', Type
+
+        ## should set up an empty database with :items, :types, and :properties
+        def self.fetch_database(nom)
+          raise "fetch_database is not implemented by the framework."
+        end
+
+        def self.store_database(nom, data)
+          raise "store_database is not imeplemented by the framework."
+        end
+
+        def self.get_database(nom)
+          @@databases[nom] ||= self.fetch_database(nom)
+        end
+
+        def self.set_database(nom, data)
+          @@databases[nom] = data
+        end
+
+        def self.store_databases
+          @@databases.keys.each do |k|
+            self.store_database(k, @@databases[k])
+          end
+        end
+
+        def self.accumulate_item_info(&block)
+          @@item ||=[]
+          @@item.unshift({})
+          yield
+          @@item.shift
+        end
+
+        def self.add_item_to_accumulator(k,v)
+          return if @@item.empty?
+          if v.is_a?(Array) && v.size == 1
+            v = v[0]
+          end
+          @@item[0][k] = v
+        end
+
+        def self.add_info(nom, t, item)
+          @@databases ||= {}
+          @@databases[nom] ||= self.fetch_database(nom)
+          @@databases[nom][t][item['id']] ||= { }
+          @@databases[nom][t][item['id']].merge!(item)
+          @@databases[nom][t][item['id']].each_pair do |k,v|
+            if v.nil? || (v.is_a?(Array) && v.empty?) ||
+               v.is_a?(String) && v == ""
+              @@databases[nom][t][item['id']].delete(k)
+            end
+          end
+          case t
+            when :types, :properties
+              @@databases[nom][t][item['id']].delete(:id)
+          end
+        end
+
+        def self.remove_info(nom, t, id)
+          @@databases[nom] ||= self.fetch_database(nom)
+          return if @@databases[nom][t].empty?
+          @@databases[nom][t].delete(id)
+        end
+
+        function 'item' do |ctx, args|
+          # need to get at the 'global' ex:database attribute
+          nom = ctx.attribute(EXHIBIT_NS, 'database', { :inherited => true, :static => true })
+          db = Fabulator::Exhibit::Actions::Lib.get_database(nom)
+          args.collect{ |a|
+            id = a.to_s
+            i = db[:items][id]
+            r = ctx.root.anon_node(id)
+            r.name = id
+            i.each_pair do |k,v|
+              next if k == "id"
+              v = [ v ] unless v.is_a?(Array)
+              v.each do |vv|
+                r.create_child(k,vv)
+              end
+            end
+            r
+          }
+        end
+
+        function 'items' do |ctx, args|
+          db = Fabulator::Exhibit::Actions::Lib.get_database(args.first.to_s)
+          db[:items].collect{ |item|
+            i = ctx.anon_node(item["id"])
+            i.name = item["id"]
+            item.each_pair do |k,v|
+              next if k == "id"
+              v = [ v ] unless v.is_a?(Array)
+              v.each do |vv|
+                i.create_child(k,vv)
+              end
+            end
+            i
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fabulator/exhibit/actions/item.rb

@@ -0,0 +1,81 @@
+require 'uuid'
+
+module Fabulator
+  module Exhibit
+    module Actions
+      class Item < Fabulator::Action
+        namespace Fabulator::EXHIBIT_NS
+        attribute :database, :inherited => true, :static => false
+        attribute :id, :eval => true, :static => false
+        attribute :type, :static => false, :inherited => true
+        attribute :label, :eval => true, :static => false
+
+        has_select
+        has_actions
+
+        def run(context, autovivify = false)
+          @context.with(context) do |ctx|
+            items = @select.run(ctx)
+
+            db = @database.run(ctx).first.to_s
+  
+            items.each do |item|
+              info = Fabulator::Exhibit::Actions::Lib.accumulate_item_info do
+                @actions.run(ctx.with_root(item))
+              end
+              info['id'] = (@id.run(ctx.with_root(item)).first.to_s rescue nil)
+              if info['id'].nil?
+                @@uuid ||= UUID.new
+                info['id'] = @@uuid.generate(:compact)
+              end
+              info['type'] = @type.run(ctx.with_root(item)).first.to_s
+              info['label'] = @label.run(ctx.with_root(item)).first.to_s
+              Fabulator::Exhibit::Actions::Lib.add_info(db, :items, info)
+            end
+          end
+        end
+      end
+
+      class Database < Fabulator::Action
+        namespace Fabulator::EXHIBIT_NS
+        attribute :database, :inherited => true, :static => false
+        attribute :mode, :default => 'merge', :static => false
+        attribute :type, :as => :scope_type, :static => false
+
+        has_actions
+
+        def run(context, autovivify = false)
+          ret = [ ]
+          @context.with(context) do |ctx|
+            nom = @database.run(ctx).first.to_s
+            mode = @mode.run(ctx).first.to_s
+            scope_type = (@scope_type.run(ctx).first.to_s rescue nil)
+            db = nil
+            if mode == 'merge' || !scope_type.nil?
+            db = Fabulator::Exhibit::Actions::Lib.fetch_database(nom)
+              if !db.nil? && mode == 'overwrite'  # !scope_type.nil? is a consequence
+                # remove any items of scope_type
+                db[:items].delete_if{ |k,v| v['type'] == scope_type }
+              end
+            end
+            if db.nil?
+              db = { :items => {}, :types => {}, :properties => {} }
+            end
+            Fabulator::Exhibit::Actions::Lib.set_database(nom, db)
+ 
+            begin
+              ret = @actions.run(ctx)
+            ensure
+              Fabulator::Exhibit::Actions::Lib.store_database(
+                nom,
+                Fabulator::Exhibit::Actions::Lib.get_database(nom)
+              )
+            end
+          end
+          return ret
+        end
+      end
+
+    end
+  end
+end

data/lib/fabulator/exhibit/actions/property.rb

@@ -0,0 +1,24 @@
+module Fabulator
+  module Exhibit
+    module Actions
+      class Property < Fabulator::Action
+        namespace Fabulator::EXHIBIT_NS
+        attribute :database, :inherited => true, :static => false
+        attribute :name, :static => false
+        attribute :valueType, :static => false
+        
+        def run(context, autovivify = false)
+          @context.with(context) do |ctx|
+            Fabulator::Exhibit::Actions::Lib.add_info(
+              @database.run(ctx).first.to_s, 
+              :properties, {
+                'id' => @name.run(ctx).first.to_s,
+                'valueType' => @valueType.run(ctx).first.to_s
+              }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fabulator/exhibit/actions/type.rb

@@ -0,0 +1,25 @@
+module Fabulator
+  module Exhibit
+    module Actions
+      class Type < Fabulator::Action
+
+        namespace Fabulator::EXHIBIT_NS
+        attribute :database, :inherited => true, :static => false
+        attribute :name, :static => false
+        attribute :pluralLabel, :static => false
+
+        def run(context, autovivify = false)
+          @context.with(context) do |ctx|
+            info = { :id => @name.run(ctx).first.to_s }
+            if !@pluralLabel.nil?
+              info['pluralLabel'] = @pluralLabel.run(ctx).first.to_s
+            end
+            Fabulator::Exhibit::Actions::Lib.add_info(
+              @database.run(ctx).first.to_s, :types, info
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fabulator/exhibit/actions/value.rb

@@ -0,0 +1,22 @@
+module Fabulator
+  module Exhibit
+    module Actions
+      class Value < Fabulator::Action
+
+        namespace Fabulator::EXHIBIT_NS
+        attribute :name, :static => false
+
+        has_select
+
+        def run(context, autovivify = false)
+          @context.with(context) do |ctx|
+            Fabulator::Exhibit::Actions::Lib.add_item_to_accumulator(
+              @name.run(ctx).first.to_s, 
+              @select.run(ctx).collect{ |s| s.value }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fabulator/exhibit/version.rb

@@ -0,0 +1,16 @@
+module Fabulator
+  module Exhibit
+    module VERSION
+      unless defined? MAJOR
+        MAJOR = 0
+        MINOR = 0
+        TINY  = 1
+        PRE   = nil
+
+        STRING = [MAJOR,MINOR,TINY].compact.join('.') + (PRE.nil? ? '' : PRE)
+
+        SUMMARY = "fabulator-exhibit #{STRING}"
+      end
+    end
+  end
+end

data/test/test_fabulator-xml.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestFabulatorXml < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def test_truth
+    assert true
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'stringio'
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/fabulator-xml'

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification 
+name: fabulator-exhibit
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- James Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-08 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: fabulator
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 29
+        segments: 
+        - 0
+        - 0
+        - 1
+        version: 0.0.1
+  type: :runtime
+  version_requirements: *id001
+description: Provides language extensions to manage Exhibit-style NoSQL databases.
+email: jgsmith@tamu.edu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- VERSION
+- features/simple-database.feature
+- features/step_definitions/exhibit_steps.rb
+- features/step_definitions/expression_steps.rb
+- features/step_definitions/xml_steps.rb
+- features/support/env.rb
+- lib/fabulator/exhibit.rb
+- lib/fabulator/exhibit/actions.rb
+- lib/fabulator/exhibit/actions/item.rb
+- lib/fabulator/exhibit/actions/property.rb
+- lib/fabulator/exhibit/actions/type.rb
+- lib/fabulator/exhibit/actions/value.rb
+- lib/fabulator/exhibit/version.rb
+- test/test_helper.rb
+- test/test_fabulator-xml.rb
+has_rdoc: true
+homepage: http://github.com/jgsmith/fabulator-exhibit
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Fabulator Extension providing Exhibit-style NoSQL databases.
+test_files: 
+- test/test_helper.rb
+- test/test_fabulator-xml.rb