ua 0.0.1

data/lib/missing/ostruct.rb

@@ -0,0 +1,284 @@
+#
+# = ostruct.rb: OpenStruct implementation
+#
+# Author:: Yukihiro Matsumoto
+# Documentation:: Gavin Sinclair
+#
+# OpenStruct allows the creation of data objects with arbitrary attributes.
+# See OpenStruct for an example.
+#
+
+#
+# An OpenStruct is a data structure, similar to a Hash, that allows the
+# definition of arbitrary attributes with their accompanying values. This is
+# accomplished by using Ruby's metaprogramming to define methods on the class
+# itself.
+#
+# == Examples:
+#
+#   require 'ostruct'
+#
+#   person = OpenStruct.new
+#   person.name    = "John Smith"
+#   person.age     = 70
+#   person.pension = 300
+#
+#   puts person.name     # -> "John Smith"
+#   puts person.age      # -> 70
+#   puts person.address  # -> nil
+#
+# An OpenStruct employs a Hash internally to store the methods and values and
+# can even be initialized with one:
+#
+#   australia = OpenStruct.new(:country => "Australia", :population => 20_000_000)
+#   p australia   # -> <OpenStruct country="Australia" population=20000000>
+#
+# Hash keys with spaces or characters that would normally not be able to use for
+# method calls (e.g. ()[]*) will not be immediately available on the
+# OpenStruct object as a method for retrieval or assignment, but can be still be
+# reached through the Object#send method.
+#
+#   measurements = OpenStruct.new("length (in inches)" => 24)
+#   measurements.send("length (in inches)")  # -> 24
+#
+#   data_point = OpenStruct.new(:queued? => true)
+#   data_point.queued?                       # -> true
+#   data_point.send("queued?=",false)
+#   data_point.queued?                       # -> false
+#
+# Removing the presence of a method requires the execution the delete_field
+# method as setting the property value to +nil+ will not remove the method.
+#
+#   first_pet = OpenStruct.new(:name => 'Rowdy', :owner => 'John Smith')
+#   first_pet.owner = nil
+#   second_pet = OpenStruct.new(:name => 'Rowdy')
+#
+#   first_pet == second_pet   # -> false
+#
+#   first_pet.delete_field(:owner)
+#   first_pet == second_pet   # -> true
+#
+#
+# == Implementation:
+#
+# An OpenStruct utilizes Ruby's method lookup structure to and find and define
+# the necessary methods for properties. This is accomplished through the method
+# method_missing and define_method.
+#
+# This should be a consideration if there is a concern about the performance of
+# the objects that are created, as there is much more overhead in the setting
+# of these properties compared to using a Hash or a Struct.
+#
+class OpenStruct
+  #
+  # Creates a new OpenStruct object.  By default, the resulting OpenStruct
+  # object will have no attributes.
+  #
+  # The optional +hash+, if given, will generate attributes and values
+  # (can be a Hash, an OpenStruct or a Struct).
+  # For example:
+  #
+  #   require 'ostruct'
+  #   hash = { "country" => "Australia", :population => 20_000_000 }
+  #   data = OpenStruct.new(hash)
+  #
+  #   p data        # -> <OpenStruct country="Australia" population=20000000>
+  #
+  def initialize(hash=nil)
+    @table = {}
+    if hash
+      hash.each_pair do |k, v|
+        k = k.to_sym
+        @table[k] = v
+        new_ostruct_member(k)
+      end
+    end
+  end
+
+  # Duplicate an OpenStruct object members.
+  def initialize_copy(orig)
+    super
+    @table = @table.dup
+    @table.each_key{|key| new_ostruct_member(key)}
+  end
+
+  #
+  # Converts the OpenStruct to a hash with keys representing
+  # each attribute (as symbols) and their corresponding values
+  # Example:
+  #
+  #   require 'ostruct'
+  #   data = OpenStruct.new("country" => "Australia", :population => 20_000_000)
+  #   data.to_h   # => {:country => "Australia", :population => 20000000 }
+  #
+  def to_h
+    @table.dup
+  end
+
+  #
+  # Yields all attributes (as a symbol) along with the corresponding values
+  # or returns an enumerator if not block is given.
+  # Example:
+  #
+  #   require 'ostruct'
+  #   data = OpenStruct.new("country" => "Australia", :population => 20_000_000)
+  #   data.each_pair.to_a  # => [[:country, "Australia"], [:population, 20000000]]
+  #
+  def each_pair
+    return to_enum __method__ unless block_given?
+    @table.each_pair{|p| yield p}
+  end
+
+  #
+  # Provides marshalling support for use by the Marshal library.
+  #
+  def marshal_dump
+    @table
+  end
+
+  #
+  # Provides marshalling support for use by the Marshal library.
+  #
+  def marshal_load(x)
+    @table = x
+    @table.each_key{|key| new_ostruct_member(key)}
+  end
+
+  #
+  # Used internally to check if the OpenStruct is able to be
+  # modified before granting access to the internal Hash table to be modified.
+  #
+  def modifiable
+    begin
+      @modifiable = true
+    rescue
+      raise TypeError, "can't modify frozen #{self.class}", caller(3)
+    end
+    @table
+  end
+  protected :modifiable
+
+  #
+  # Used internally to defined properties on the
+  # OpenStruct. It does this by using the metaprogramming function
+  # define_singleton_method for both the getter method and the setter method.
+  #
+  def new_ostruct_member(name)
+    name = name.to_sym
+    unless respond_to?(name)
+      define_singleton_method(name) { @table[name] }
+      define_singleton_method("#{name}=") { |x| modifiable[name] = x }
+    end
+    name
+  end
+  protected :new_ostruct_member
+
+  def method_missing(mid, *args) # :nodoc:
+    mname = mid.id2name
+    len = args.length
+    if mname.chomp!('=')
+      if len != 1
+        raise ArgumentError, "wrong number of arguments (#{len} for 1)", caller(1)
+      end
+      modifiable[new_ostruct_member(mname)] = args[0]
+    elsif len == 0
+      @table[mid]
+    else
+      raise NoMethodError, "undefined method `#{mid}' for #{self}", caller(1)
+    end
+  end
+
+  # Returns the value of a member.
+  #
+  #   person = OpenStruct.new('name' => 'John Smith', 'age' => 70)
+  #   person[:age] # => 70, same as ostruct.age
+  #
+  def [](name)
+    @table[name.to_sym]
+  end
+
+  #
+  # Sets the value of a member.
+  #
+  #   person = OpenStruct.new('name' => 'John Smith', 'age' => 70)
+  #   person[:age] = 42 # => equivalent to ostruct.age = 42
+  #   person.age # => 42
+  #
+  def []=(name, value)
+    modifiable[new_ostruct_member(name)] = value
+  end
+
+  #
+  # Remove the named field from the object. Returns the value that the field
+  # contained if it was defined.
+  #
+  #   require 'ostruct'
+  #
+  #   person = OpenStruct.new('name' => 'John Smith', 'age' => 70)
+  #
+  #   person.delete_field('name')  # => 'John Smith'
+  #
+  def delete_field(name)
+    sym = name.to_sym
+    singleton_class.__send__(:remove_method, sym, "#{name}=")
+    @table.delete sym
+  end
+
+  InspectKey = :__inspect_key__ # :nodoc:
+
+  #
+  # Returns a string containing a detailed summary of the keys and values.
+  #
+  def inspect
+    str = "#<#{self.class}"
+
+    ids = (Thread.current[InspectKey] ||= [])
+    if ids.include?(object_id)
+      return str << ' ...>'
+    end
+
+    ids << object_id
+    begin
+      first = true
+      for k,v in @table
+        str << "," unless first
+        first = false
+        str << " #{k}=#{v.inspect}"
+      end
+      return str << '>'
+    ensure
+      ids.pop
+    end
+  end
+  alias :to_s :inspect
+
+  attr_reader :table # :nodoc:
+  protected :table
+
+  #
+  # Compares this object and +other+ for equality.  An OpenStruct is equal to
+  # +other+ when +other+ is an OpenStruct and the two objects' Hash tables are
+  # equal.
+  #
+  def ==(other)
+    return false unless other.kind_of?(OpenStruct)
+    @table == other.table
+  end
+
+  #
+  # Compares this object and +other+ for equality.  An OpenStruct is eql? to
+  # +other+ when +other+ is an OpenStruct and the two objects' Hash tables are
+  # eql?.
+  #
+  def eql?(other)
+    return false unless other.kind_of?(OpenStruct)
+    @table.eql?(other.table)
+  end
+
+  # Compute a hash-code for this OpenStruct.
+  # Two hashes with the same content will have the same hash code
+  # (and will be eql?).
+  def hash
+    @table.hash
+  end
+end

data/lib/ua/uadb.rb

@@ -0,0 +1,42 @@
+module Ua
+  class SQLite3Table
+    def initialize(db, table)
+	   require 'SQLite3'
+	   @db, @table = db, table
+	   @database = ::SQLite3::Database.new(@db + ".db") 
+	end
+  
+	def [](a)
+	   case a
+	     when lambda{|x| Integer(x) rescue false}
+		     @database.execute "select * from #{@table} where id=?", a.to_i
+		   when Hash
+		     k = a.keys
+		     x = k.map{|name| "#{name} = ?"}.join(" and ")
+		     y = k.map{|name| a[name]}
+		     @database.execute "select * from #{@table} where " + x, y 
+	     end
+    end
+  end
+  
+  class SQLite3DB
+    def initialize(name)
+      @name = name
+	end
+	def [](a)
+	  SQLite3Table.new(@name, a)
+	end
+  end
+  
+  class SQLite3
+    def [](a)
+	   SQLite3DB.new(a)
+	  end
+  end
+  
+  module SQLite3Support
+    def default_context
+	   set "db3", SQLite3.new
+	  end
+  end
+end

data/lib/ua/version.rb

@@ -0,0 +1,3 @@
+module Ua
+  VERSION = "0.0.1"
+end

data/lib/ua.rb

@@ -0,0 +1,375 @@
+require "ua/version"
+require 'erb'
+require 'ostruct'
+module Ua
+  module Commands
+  end
+  class Application
+      module UAClass; end
+      module Apply; end
+      def initialize
+         @store   = {}
+         @context = {}
+      end
+      
+      def default_context
+         that = self
+         context Array, :app do |arr|
+            arr.map{|a| context(a, :app)}.join
+         end
+      
+        context Apply, :app do |arr|
+           get(arr.stream_).map{|a|that.app a}.join
+        end
+        
+        context String, :app do |str|
+           str
+        end
+        
+        context UAClass, :app do |element|
+          element.render
+        end
+        
+        context Array, :stream_add do |arr, *a|
+          arr.concat a
+          ""
+        end
+        context String, :get do |obj, *a|
+           context(get(obj), *a)
+        end
+        
+        context UAClass, :stream_add do |obj, *a|
+          obj.stream_ ||= stream_generate
+          get(obj.stream_).concat a
+          obj.extend Apply
+          ""
+        end
+        
+        context UAClass, :append_add do |obj, *a|
+          obj.stream_ ||= stream_generate
+          get(obj.stream_).concat a
+          ""
+        end
+     end
+      
+      def make_context(a, b)
+         a[0] = get(a[0]).class if String === a[0] && has?(a[0])
+         a[0] = a[0].class unless Module === a[0]
+         @context[a] = b
+      end
+      
+      def tmpid(prefix = "temp")
+         r = get(count = "#{prefix}.id") || 0
+         r += 1
+         set count, r
+         "#{prefix}.#{r}"
+      end
+      
+      def output_by_context(a, b, *c)
+         r = a.singleton_class rescue a.class
+         r.ancestors.each{|i|
+            h = i.instance_method(:uacontext) rescue nil
+            catch(:continue){
+              return h.bind(a).call(b, *c) if h
+            }
+         }
+         r.ancestors.each{|i|
+            h = @context[[i, b]]            
+            catch(:continue){
+              return a.instance_exec(a, *c, &h) if h
+            }
+         }
+         puts "Can't find a handler #{a.class} #{b}"
+         raise "Can't find a handler #{a.class} #{b}"
+=begin
+      ensure
+
+        if $@
+          unless $@.index{|x| x=="UAException"}
+            $@.unshift("UAEnd")
+            $@.unshift("UAException")
+          end
+          l, r = $@.index("UAException"), $@.index("UAEnd")
+          u = $@.slice!(l..r)
+          u[-1, 0] = "context #{a.class} #{b}"
+          u += $@
+          $@.replace u
+        end
+=end
+      end
+      
+      
+      #
+      # setup an output variable
+      #
+      def _parent(a)
+        u = @store
+        col = ""
+        arr = a.split(".") 
+        arr[0..-2].each{|x|
+          col << "." << x 
+          if u[x] == nil
+            u[x] = {}
+          elsif !u[x].respond_to?(:[])
+            raise "#{col} is not valid"
+          end
+          u = u[x] 
+        }
+        [u, arr[-1]]
+      end 
+      
+      def set(a, b)
+         path, val = _parent(a)
+         path[val] = b
+         b
+      end
+      
+      def get(a)
+        path, val = _parent(a)
+        path[val] 
+      end
+      
+      TOPLEVEL = "com.ua.root"      
+      def go!(name = TOPLEVEL)
+         puts app(name)
+      end
+      
+      def app(name = TOPLEVEL)
+         context(get(name), :app)
+      end
+      
+      
+      def context(a, b = Ua::Application.top.context, *c, &bl)
+        if block_given?
+           make_context([a, b], bl)
+        else
+           output_by_context(a, b, *c)
+        end
+      end
+      
+      
+      
+      def make_uaclass(a, *ar, &block)
+        autoinit = false
+        block ||= begin
+           autoinit = true
+           lambda{
+              "<%= context(get(stream_), :app) %>"
+           }
+        end
+        that = self
+        code = block.call
+        codename = "proc.#{a}"
+        set codename, code
+        klass = Class.new(OpenStruct) do
+          include UAClass
+          include Enumerable
+          define_method(:initialize) do |*args|
+          begin
+              Ua::Application.push_app that
+              super(*args)
+              self.stream_ = that.stream_generate
+              self.id_     = that.tmpid("object")
+              that.set self.id_, self
+          ensure
+              Ua::Application.pop
+          end
+          end
+          def mapjoin
+            map{|x| yield x}.join
+          end
+          def each
+            get(stream_).each{|x|
+              yield x
+            }
+          end
+          define_method(:classid) do
+            a
+          end
+          define_method(:prototype) do
+            klass
+          end
+          define_method(:erb) do |text__|
+          begin
+            Ua::Application.push_app that  
+            ERB.new(text__).result(binding)
+          ensure
+            Ua::Application.pop
+          end
+          end
+          define_method(:render) do
+          begin  
+            Ua::Application.push_app that          
+            erb get codename
+          ensure
+            Ua::Application.pop
+          end
+          end
+          define_singleton_method(:to_s) do
+            a
+          end
+        end 
+        x = klass.new
+        klass.const_set :Singleton_, x
+        x
+      end
+     
+      
+      
+      def stream_generate
+        u = tmpid
+        set u, []
+        u
+      end
+      
+      def create(id, opt = {}, &b)
+        x = get(id).prototype.new
+        opt.each{|k, v| x.send "#{k}=", v }
+        x         
+      end
+      
+      def add(a = tmpid, *ar, &block)
+        set a, make_uaclass(a, *ar, &block)
+        get a
+      end
+      
+      def delete(obj)
+        set obj.id_, nil
+      end
+      
+      module ArgVoid; end
+      
+      def self.push(app = ArgVoid, context = ArgVoid, controller = ArgVoid)
+        app     = app     == ArgVoid ? @app_stack.last.app : app
+        context = context == ArgVoid ? @app_stack.last.context : context
+        controller = controller == ArgVoid ? @app_stack.last.controller : controller
+        @app_stack.push StackFrame.new(app, context, controller)
+      end
+      
+      def self.push_app(app)
+         self.push(app)
+      end
+      
+      
+      def self.pop
+        @app_stack.pop
+      end
+      def self.top
+        @app_stack.last
+      end
+      def self.top_app
+        top.app
+      end
+      
+      app = SINGLETON_APP = new
+      
+      StackFrame = Struct.new(:app, :context, :controller)
+      @app_stack = [StackFrame.new(app, :app, eval('self', TOPLEVEL_BINDING))]
+      
+      def initialize
+        @store   = {}
+        @context = {}
+        bootup
+      end
+      
+      def bootup
+        default_context
+        add("com.ua.root").prototype.send :include, Ua::Application::Apply
+      end
+      
+      app.bootup
+      
+      def self.singleton
+         SINGLETON_APP
+      end
+      
+      def stream(a, *b)
+        context(get(a), :stream_add, *b)
+      end
+      
+      def append(a, *b)
+        context(get(a), :append_add, *b)
+      end
+      
+      def self.export_commands(*names)
+        that = self
+        names.each{|name|  
+          (Commands).send(:define_method, name) do |*a, &b|
+             that.top_app.send(name, *a, &b)
+          end
+        }
+      end
+      
+      def has?(key)
+        get(key)
+      end
+      
+      def stack_of(name)
+         stack = "stack.#{name}"
+         if has?(stack)
+           get(stack)
+         else
+           set stack, (a = [])
+           a
+         end
+      end
+      
+      
+      def get_local(name)
+        local = "local.#{name}"
+        return get local if has?(local)  
+        add local
+        get local
+      end
+      
+      def set_local(name, val)
+        local = "local.#{name}"
+        set local, val
+        val
+      end
+      
+      def push_local(name, newval = add)
+        local = "local.#{name}"
+        stack_of(local).push get local
+        set local, newval
+        newval
+      end    
+      
+      def pop_local(name)
+        local = "local.#{name}"
+        r = get local
+        set local, stack_of(local).pop
+        r
+      end
+      
+        
+      export_commands :set, :go!,    :add,               :create,
+                      :get, :stream, :append,  :stream_generate,
+                      :get_local, :set_local, :push_local, :pop_local, :delete
+                      
+  end
+    module Commands
+        def context(obj, ctxt = Ua::Application.top.context, &b)
+          Ua::Application.push(Ua::Application::ArgVoid, 
+                               ctxt,   
+                               self
+                              )
+          Ua::Application.top_app.context(obj, ctxt, &b)
+        ensure
+          Ua::Application.pop
+        end
+        alias model add
+        alias view context
+        alias link stream
+        alias new create        
+      end            
+  
+end
+
+
+require 'ua/uadb'
+require 'ua/util'
+if !(Ua.const_get(:NoConflict) rescue nil)
+  include Ua::Commands
+  include Ua::Util
+end

data/test/Hello.cpp

@@ -0,0 +1,5 @@
+ 
+		   extern "C" int __stdcall add(int a, int b){
+			   return a + b;
+		   }
+