spqr 0.0.1

data/lib/spqr/constants.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+# Constants for SQPR
+#
+# Copyright (c) 2009 Red Hat, Inc.
+#
+# Author:  William Benton (willb@redhat.com)
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+module SPQR
+  
+  module XmlConstants
+    Type = {
+      'absTime' => 'Qmf::TYPE_ABSTIME',
+      'array' => 'Qmf::TYPE_ARRAY',      # XXX:  is this right?
+      'bool' => 'Qmf::TYPE_BOOL',
+      'deltaTime' => 'Qmf::TYPE_DELTATIME',
+      'double' => 'Qmf::TYPE_DOUBLE',
+      'float' => 'Qmf::TYPE_FLOAT',
+      'int16' => 'Qmf::TYPE_INT16',
+      'int32' => 'Qmf::TYPE_INT32',
+      'int64' => 'Qmf::TYPE_INT64',
+      'int' => 'Qmf::TYPE_INT64',
+      'int8' => 'Qmf::TYPE_INT8',
+      'list' => 'Qmf::TYPE_LIST',        # XXX:  is this right?
+      'lstr' => 'Qmf::TYPE_LSTR',
+      'string' => 'Qmf::TYPE_LSTR',
+      'map' => 'Qmf::TYPE_MAP',
+      'objId' => 'Qmf::TYPE_REF',
+      'sstr' => 'Qmf::TYPE_SSTR',
+      'uint16' => 'Qmf::TYPE_UINT16',
+      'uint32' => 'Qmf::TYPE_UINT32',
+      'uint64' => 'Qmf::TYPE_UINT64',
+      'uint' => 'Qmf::TYPE_UINT64',
+      'uint8' => 'Qmf::TYPE_UINT8',
+      'uuid' => 'Qmf::TYPE_UUID'
+    }
+
+    Access = {
+      "RC" => 'Qmf::ACCESS_READ_CREATE',
+      "RW" => 'Qmf::ACCESS_READ_WRITE',
+      "RO" => 'Qmf::ACCESS_READ_ONLY',
+      "R" => 'Qmf::ACCESS_READ_ONLY'
+    }
+
+    Direction = {
+      "I" => 'Qmf::DIR_IN',
+      "O" => 'Qmf::DIR_OUT',
+      "IO" => 'Qmf::DIR_IN_OUT',
+      "i" => 'Qmf::DIR_IN',
+      "o" => 'Qmf::DIR_OUT',
+      "io" => 'Qmf::DIR_IN_OUT',
+      "in" => 'Qmf::DIR_IN',
+      "out" => 'Qmf::DIR_OUT',
+      "inout" => 'Qmf::DIR_IN_OUT'
+    }
+  end
+
+end

data/lib/spqr/manageable.rb

@@ -0,0 +1,222 @@
+# SPQR:  Schema Processor for QMF/Ruby agents
+#
+# Manageable object mixin and support classes.
+#
+# Copyright (c) 2009 Red Hat, Inc.
+#
+# Author:  William Benton (willb@redhat.com)
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+module SPQR
+  class ManageableMeta < Struct.new(:classname, :package, :description, :mmethods, :options, :statistics, :properties)
+    def initialize(*a)
+      super *a
+      self.options = (({} unless self.options) or self.options.dup)
+      self.statistics = [] unless self.statistics
+      self.properties = [] unless self.properties
+      self.mmethods ||= []
+    end
+
+    def declare_method(name, desc, options, blk=nil)
+      result = MethodMeta.new name, desc, options
+      blk.call(result.args) if blk
+      self.mmethods << result
+      self.mmethods[-1]
+    end
+
+    def declare_statistic(name, kind, options)
+      declare_basic(:statistic, name, kind, options)
+    end
+
+    def declare_property(name, kind, options)
+      declare_basic(:property, name, kind, options)
+    end
+
+    private
+    def declare_basic(what, name, kind, options)
+      what_plural = "#{what.to_s.gsub(/y$/, 'ie')}s"
+      w_get = what_plural.to_sym
+      w_set = "#{what_plural}=".to_sym
+
+      self.send(w_set, (self.send(w_get) or []))
+
+      w_class = "#{what.to_s.capitalize}Meta"
+      self.send(w_get) << SPQR.const_get(w_class).new(name, kind, options)
+    end
+  end
+
+  class MethodMeta < Struct.new(:name, :description, :args, :options)
+    def initialize(*a)
+      super *a
+      self.options = (({} unless self.options) or self.options.dup)
+      self.args = gen_args
+    end
+
+    private
+    def gen_args
+      result = []
+
+      def result.declare(name, kind, direction, description=nil, options=nil)
+        options ||= {}
+        arg = ::SPQR::ArgMeta.new name, kind, direction, description, options.dup
+        self << arg
+      end
+
+      result
+    end
+  end
+
+  class ArgMeta < Struct.new(:name, :kind, :direction, :description, :options)
+    def initialize(*a)
+      super *a
+      self.options = (({} unless self.options) or self.options.dup)
+    end
+  end
+
+  class PropertyMeta < Struct.new(:name, :kind, :options)
+    def initialize(*a)
+      super *a
+      self.options = (({} unless self.options) or self.options.dup)
+    end
+  end
+
+  class StatisticMeta < Struct.new(:name, :kind, :options)
+    def initialize(*a)
+      super *a
+      self.options = (({} unless self.options) or self.options.dup)
+    end
+  end
+
+  module ManageableClassMixins
+    def spqr_meta
+      @spqr_meta ||= ::SPQR::ManageableMeta.new
+    end
+    
+    def spqr_logger=(logger)
+      @spqr_log = logger
+    end
+    
+    def spqr_logger
+      @spqr_log || ::SPQR::Sink.new
+    end
+    
+    # Exposes a method to QMF
+    def spqr_expose(name, description=nil, options=nil, &blk)
+      spqr_meta.declare_method(name, description, options, blk)
+    end      
+    
+    def spqr_package(nm)
+      spqr_meta.package = nm
+    end
+    
+    def spqr_class(nm)
+      spqr_meta.classname = nm
+    end
+    
+    def spqr_description(d)
+      spqr_meta.description = d
+    end
+    
+    def spqr_options(opts)
+      spqr_meta.options = opts.dup
+    end      
+    
+    def spqr_statistic(name, kind, options=nil)
+      spqr_meta.declare_statistic(name, kind, options)
+      
+      self.class_eval do
+        # XXX: are we only interested in declaring a reader for
+        # statistics?  Doesn't it really makes more sense for the managed
+        # class to declare a method with the same name as the
+        # statistic so we aren't declaring anything at all here?
+        
+        # XXX: should cons up a "safe_attr_reader" method that works
+        # like this:
+        attr_reader name.to_sym unless instance_methods.include? "#{name}"
+        attr_writer name.to_sym unless instance_methods.include? "#{name}="
+      end
+    end
+    
+    def spqr_property(name, kind, options=nil)
+      spqr_meta.declare_property(name, kind, options)
+      
+      # add a property accessor to instances of other
+      self.class_eval do
+        # XXX: should cons up a "safe_attr_accessor" method that works like this:
+        attr_reader name.to_sym unless instance_methods.include? "#{name}"
+        attr_writer name.to_sym unless instance_methods.include? "#{name}="
+      end
+      
+      if options and options[:index]
+        # if this is an index property, add a find-by method if one
+        # does not already exist
+        spqr_define_index_find(name)
+      end
+    end
+    
+    private
+    def spqr_define_index_find(name)
+      find_by_prop = "find_by_#{name}".to_sym
+
+      return if self.respond_to? find_by_prop
+
+      define_method find_by_prop do |arg|
+        raise "#{self} must define find_by_#{name}(arg)"
+      end
+    end
+  end
+
+  module Manageable
+    def qmf_oid
+      result = 0
+      if self.respond_to? :spqr_object_id 
+        result = spqr_object_id
+      else
+        result = object_id
+      end
+      
+      result & 0x7fffffff
+    end
+
+    def qmf_id
+      [qmf_oid, self.class.class_id]
+    end
+
+    def log
+      self.class.spqr_logger
+    end
+
+    def self.included(other)
+      class << other
+        include ManageableClassMixins
+      end
+
+      unless other.respond_to? :find_by_id
+        def other.find_by_id(id)
+          raise "#{self} must define find_by_id(id)"
+        end
+      end
+
+      unless other.respond_to? :find_all
+        def other.find_all
+          raise "#{self} must define find_all"
+        end
+      end
+
+      unless other.respond_to? :class_id
+        def other.class_id
+          package_list = spqr_meta.package.to_s.split(".")
+          cls = spqr_meta.classname.to_s or self.name.to_s
+          ((package_list.map {|pkg| pkg.capitalize} << cls).join("::")).hash & 0x7fffffff
+        end
+      end
+
+      other.spqr_class other.name.to_sym
+    end
+  end
+end

data/lib/spqr/spqr.rb

@@ -0,0 +1,16 @@
+# SPQR:  Schema Processor for QMF/Ruby agents
+#
+# Copyright (c) 2009 Red Hat, Inc.
+#
+# Author:  William Benton (willb@redhat.com)
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spqr/utils'
+require 'spqr/constants'
+require 'spqr/codegen'
+require 'spqr/manageable'

data/lib/spqr/utils.rb

@@ -0,0 +1,88 @@
+# Utility functions and modules for SPQR
+#
+# Copyright (c) 2009 Red Hat, Inc.
+#
+# Author:  William Benton (willb@redhat.com)
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+module SPQR
+  class Sink
+    def method_missing(*args)
+      yield if block_given?
+      nil
+    end
+  end
+
+  module PrettyPrinter
+    def writemode
+      $PP_WRITEMODE ||= File::WRONLY|File::CREAT|File::TRUNC
+    end
+
+    def stack
+      @fstack ||= [STDOUT]
+    end
+
+    def inc_indent
+      @indent = indent + 2
+    end
+
+    def dec_indent
+      @indent = indent - 2
+    end
+
+    def indent
+      @indent ||= 0
+    end
+
+    def outfile
+      @fstack[-1] or STDOUT
+    end
+
+    def pp(s)
+      outfile.puts "#{' ' * indent}#{s}\n"
+    end
+
+    def pp_decl(kind, name, etc=nil)
+      pp "#{kind} #{name}#{etc}"
+      inc_indent
+      yield if block_given?
+      dec_indent
+      pp "end"
+    end
+
+    def pp_call(callable, args)
+      arg_repr = args.map {|arg| (arg.inspect if arg.kind_of? Hash) or arg}.join(', ')
+      pp "#{callable}(#{arg_repr})"
+    end
+
+    def pp_invoke(receiver, method, args)
+      pp_call "#{receiver}.#{method}", args
+    end
+
+    def with_output_to(filename, &action)
+      File::open(filename, writemode) do |of|
+        stack << of
+        action.call      
+        stack.pop
+      end
+    end
+  end
+
+  module MiscUtil
+    def symbolize_dict(k, kz=nil)
+      k2 = {}
+      kz ||= k.keys
+
+      k.keys.each do |key|
+        k2[key.to_sym] = k[key] if (kz.include?(key) or kz.include?(key.to_sym))
+      end
+
+      k2
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'spqr/spqr'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

data/spec/spqr_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+module SPQR
+  
+end

data/spqr.spec.in

@@ -0,0 +1,95 @@
+# Generated from <%= File::basename(format.gem_path) %> by gem2rpm -*- rpm-spec -*-
+%define ruby_sitelib %(ruby -rrbconfig -e "puts Config::CONFIG['sitelibdir']")
+%define gemdir %(ruby -rubygems -e 'puts Gem::dir' 2>/dev/null)
+%define gemname <%= spec.name %>
+%define geminstdir %{gemdir}/gems/%{gemname}-%{version}
+
+Summary: <%= spec.summary.gsub(/\.$/, "") %>
+Name: rubygem-%{gemname}
+Version: <%= spec.version %>
+Release: 1%{?dist}
+Group: Development/Languages
+License: ASL 2.0
+URL: <%= spec.homepage %>
+Source0: <%= download_path %>%{gemname}-%{version}.gem
+BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
+Requires: rubygems
+Requires: ruby(abi) = 1.8
+Requires: ruby-qmf
+<% for d in spec.dependencies %>
+<% for req in d.version_requirements.to_rpm %>
+Requires: rubygem(<%= d.name %>) <%= req  %>
+<% end %>
+<% end %>
+BuildRequires: ruby > 1.8
+BuildRequires: rubygems
+<% if spec.extensions.empty? %>
+BuildArch: noarch
+<% end %>
+Provides: rubygem(%{gemname}) = %{version}
+
+%description
+<%= spec.description.to_s.chomp.word_wrap(78) + "\n" %>
+
+<% if nongem %>
+%package -n ruby-%{gemname}
+Summary: <%= spec.summary.gsub(/\.$/, "") %>
+Group: Development/Languages
+Requires: rubygem(%{gemname}) = %{version}
+<% spec.files.select{ |f| spec.require_paths.include?(File::dirname(f)) }.reject { |f| f =~ /\.rb$/ }.collect { |f| File::basename(f) }.each do |p| %>
+Provides: ruby(<%= p %>) = %{version}
+<% end %>
+%description -n ruby-%{gemname}
+<%= spec.description.to_s.chomp.word_wrap(78) + "\n" %>
+<% end # if nongem %>
+
+%prep
+
+%build
+
+%install
+rm -rf %{buildroot}
+mkdir -p %{buildroot}%{gemdir}
+<% rdoc_opt = spec.has_rdoc ? "--rdoc " : "" %>
+gem install --local --install-dir %{buildroot}%{gemdir} \
+            --force <%= rdoc_opt %>%{SOURCE0}
+<% unless spec.executables.empty? %>
+mkdir -p %{buildroot}/%{_bindir}
+mv %{buildroot}%{gemdir}/bin/* %{buildroot}/%{_bindir}
+rmdir %{buildroot}%{gemdir}/bin
+find %{buildroot}%{geminstdir}/bin -type f | xargs chmod a+x
+<% end %>
+<% if nongem %>
+mkdir -p %{buildroot}%{ruby_sitelib}
+<% spec.files.select{ |f| spec.require_paths.include?(File::dirname(f)) }.each do |p| %>
+ln -s %{gemdir}/gems/%{gemname}-%{version}/<%= p %> %{buildroot}%{ruby_sitelib}
+<% end %>
+<% end # if nongem %>
+
+%clean
+rm -rf %{buildroot}
+
+%files
+%defattr(-, root, root, -)
+<% for f in spec.executables %>
+%{_bindir}/<%= f %>
+<% end %>
+%{gemdir}/gems/%{gemname}-%{version}/
+<% if spec.has_rdoc %>
+%doc %{gemdir}/doc/%{gemname}-%{version}
+<% end %>
+<% for f in spec.extra_rdoc_files %>
+%doc %{geminstdir}/<%= f %>
+<% end %>
+%{gemdir}/cache/%{gemname}-%{version}.gem
+%{gemdir}/specifications/%{gemname}-%{version}.gemspec
+
+<% if nongem %>
+%files -n ruby-%{gemname}
+%defattr(-, root, root, -)
+%{ruby_sitelib}/*
+<% end # if nongem %>
+
+%changelog
+* <%= Time.now.strftime("%a %b %d %Y") %> <%= packager %> - <%= spec.version %>-1
+- Initial package