omf_web 0.9.9 → 1.0.0

data/lib/omf-web/theme/bright/stacked_renderer.rb

@@ -1,58 +1,59 @@
 
 require 'omf-web/theme/bright/widget_chrome'
+require 'omf-web/theme/bright/layout_renderer'
 
 module OMF::Web::Theme
-  
-  class StackedRenderer
-    
+
+  class StackedRenderer < LayoutRenderer
+
     def initialize(stacked_widget, widgets, active_index, opts)
       @stacked_widget = stacked_widget
       @widgets = widgets
       @active_index = active_index
       @helper = StackedRendererHelper.new(widgets, active_index, opts)
       @opts = opts
-    end    
-    
+    end
+
     def to_html()
       wp = "w#{@helper.object_id}"
       @opts[:menu] = @widgets.each_with_index.map do |w, i|
-        wc = w.widget_type.split('/').inject([]) do |a, e| 
-                a << (a.empty? ? e : "#{a[-1]}_#{e}") 
+        wc = w.widget_type.split('/').inject([]) do |a, e|
+                a << (a.empty? ? e : "#{a[-1]}_#{e}")
               end
         {
-          :name => w.name, 
-          :class => wc.join(' '), 
-          :is_active => (@active_index == i), 
+          :name => w.name,
+          :class => wc.join(' '),
+          :is_active => (@active_index == i),
           :id => "#{wp}_l_#{i}",
           :js_function => 'OML.show_widget',
           :inner_class => wp,
           :index => i,
           :widget_id => w.dom_id
         }
-      end     
+      end
       WidgetChrome.new(@stacked_widget, @helper, @opts).to_html
-    end    
-  end      
+    end
+  end
 
   class StackedRendererHelper < Erector::Widget
-    
+
     def initialize(widgets, active_index, opts)
       super opts
       @widgets = widgets
       @active_index = active_index
-    end    
+    end
 
     def content()
       #widget @active_widget
-      widgets = @widgets  
+      widgets = @widgets
       prefix = "w#{self.object_id}"
       @widgets.each_with_index do |w, i|
         style = i == @active_index ? '' : 'display:none'
         div :id => "#{prefix}_#{i}", :class => prefix, :style => style do
-         rawtext w.content.to_html      
+         rawtext w.content.to_html
         end
-      end 
+      end
     end
-    
+
   end
 end

data/lib/omf-web/theme.rb

@@ -2,29 +2,34 @@
 
 module OMF::Web::Theme
   extend OMF::Common::Loggable
-  
+
   DEFAULT_THEME = 'omf-web/theme/bright'
   @@search_order = [DEFAULT_THEME]  # default theme
   @@loaded = {}
   @@additional_renderers = {}
-  
+
   def self.theme=(theme)
     if theme
       unless theme.match '.*/'
         theme = "omf-web/theme/#{theme}" # add default name space
       end
       @@loaded = {}
-      @@search_order = [theme] 
+      @@search_order = [theme]
       Kernel::require "#{theme}/init"
     end
   end
-  
+
+  def self.include_css(css_file)
+    ::Kernel.require 'omf-web/theme/abstract_page'
+    OMF::Web::Theme::AbstractPage.add_depends_on(:css, "/resource/#{css_file}")
+  end
+
   def self.register_renderer(name, klass, theme = DEFAULT_THEME)
     tr = @@additional_renderers[theme.to_s] ||= {}
     tr[name] = klass
   end
-  
-  # Set additional themes to search in the given order for 
+
+  # Set additional themes to search in the given order for
   # implementations of renderes. Allows for partial override
   # in new themes.
   #
@@ -32,8 +37,8 @@ module OMF::Web::Theme
     @@loaded = {}
     @@search_order = search_order if search_order
   end
-  
-  
+
+
   def self.require(name)
     name = name.to_sym
     return if @@loaded[name]
@@ -45,7 +50,7 @@ module OMF::Web::Theme
           Kernel::require "#{theme}/#{name}"
         end
         @@loaded[name] = true
-        debug "Using renderer '#{theme}/#{name}'"        
+        debug "Using renderer '#{theme}/#{name}'"
         return
       rescue LoadError => le
         # Move on to the next one

data/lib/omf-web/thin/runner.rb

@@ -11,26 +11,27 @@ module Thin
       true # will be verified later
     end
   end
-end 
+end
 
 module OMF::Web
   class Runner < Thin::Runner
     include OMF::Common::Loggable
-    
+
     @@instance = nil
-    
+
     def self.instance
       @@instance
     end
-  
+
     attr_reader :options
-    
+
     def initialize(argv, opts = {})
       raise "SINGLETON" if @@instance
-      
+      @@instance = self
+
       @argv = argv
       sopts = opts.delete(:ssl) # runner has it's own idea of ssl options
-      
+
       # Default options values
       app_name = opts[:app_name] || 'omf_web_app'
       @options = {
@@ -46,68 +47,70 @@ module OMF::Web
         :max_persistent_conns => Thin::Server::DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS,
         :require              => [],
         :wait                 => Thin::Controllers::Cluster::DEFAULT_WAIT_TIME,
- 
+
         :rackup               => File.dirname(__FILE__) + '/../config.ru',
         :static_dirs          => ["#{File.dirname(__FILE__)}/../../../share/htdocs"],
         :static_dirs_pre      => ["./resources"],  # directories to prepend to 'static_dirs'
-        
+
         :handlers             => {}  # procs to call at various times of the server's life cycle
       }.merge(opts)
       # Search path for resource files is concatination of 'pre' and 'standard' static dirs
       @options[:static_dirs] = @options[:static_dirs_pre].concat(@options[:static_dirs])
-        
- 
- 
+
+
+
       print_options = false
       p = parser
       p.separator ""
-      p.separator "OMF options:"
-      p.on("--theme THEME", "Select web theme") do |t| OMF::Web::Theme.theme = t end                
-      
-      p.separator ""
-      p.separator "Testing options:"
-      p.on("--disable-https", "Run server without SSL") do sopts = nil end                
-      p.on("--print-options", "Print option settings after parsing command lines args") do print_options = true end                      
-  
+      p.separator "OMF Web options:"
+      p.on("--theme THEME", "Select web theme") do |t| OMF::Web::Theme.theme = t end
+
       # Allow application to add it's own parsing options
       if ph = @options[:handlers][:pre_parse]
-        ph.call(p)
+        ph.arity == 1 ? ph.call(p) : ph.call(p, self)
       end
 
+      p.separator ""
+      p.separator "Testing options:"
+      p.on("--disable-https", "Run server without SSL") do sopts = nil end
+      p.on("--print-options", "Print option settings after parsing command lines args") do print_options = true end
+      p.separator ""
+
       parse!
-      # WHY IS THIS HERE
-      # unless life_cycle(:post_parse)
-        # puts p.to_s
-        # abort()
-      # end
+
       if sopts
         @options[:ssl] = true
         @options[:ssl_key_file] ||= sopts[:key_file]
         @options[:ssl_cert_file] ||= sopts[:cert_file]
         @options[:ssl_verify] ||= sopts[:verify_peer]
       end
+      life_cycle(:post_parse)
 
       # Change the name of the root logger so we can apply different logging
-      # policies depending on environment. 
+      # policies depending on environment.
       #
       OMF::Common::Loggable.set_environment @options[:environment]
 
+      if css = opts[:include_css]
+        require 'omf-web/theme'
+        OMF::Web::Theme.include_css(css)
+      end
+
       if print_options
         require 'pp'
         pp @options
-      end            
-      
-      @@instance = self
+      end
+
     end
-    
+
     def life_cycle(step, &exception_block)
       begin
         if (p = @options[:handlers][step])
-          p.call()
+          p.arity == 0 ? p.call() : p.call(self)
         end
       rescue => ex
         if exception_block
-          begin 
+          begin
             exception_block.call(ex)
           rescue => ex2
             error ex2
@@ -118,8 +121,8 @@ module OMF::Web
           debug "#{ex.backtrace.join("\n")}"
         end
       end
-    end    
-    
+    end
+
     def run!
       if theme = @options[:theme]
         require 'omf-web/theme'
@@ -131,4 +134,3 @@ module OMF::Web
 end
 
 
-  

data/lib/omf-web/thin/server.rb

@@ -0,0 +1,255 @@
+require 'json'
+require 'omf_common/lobject'
+require 'omf_web'
+
+module OMF::Web
+
+  # Most of the code to run an OMF Web server from a configuration file
+  #
+  # USAGE:
+  #
+  #
+  class Server < OMF::Common::LObject
+
+    def self.start(server_name, description, top_dir, opts = {})
+      self.new(server_name, description, top_dir, opts)
+    end
+
+    def initialize(server_name, description, top_dir, opts)
+      OMF::Common::Loggable.init_log server_name
+
+      opts = {
+        static_dirs_pre: ["#{top_dir}/htdocs"],
+        handlers: {
+          pre_parse: lambda do |p, runner|
+            p.on("--config CONF_FILE", "File holding description of web site") {|f| runner.options[:omf_config_file] = f}
+            p.on("--top-dir DIR", "Directory to start from for relative data paths [directory of config file]") {|td| @top_dir = td }
+          end,
+          post_parse: lambda { |r| load_environment(r.options) },
+        },
+        authentication: {
+          required: false
+        }
+      }.merge(opts)
+
+      @top_dir = top_dir
+      @databases = {}
+
+      OMF::Web.start(opts)
+    end
+
+    def load_environment(opts)
+      unless cf = opts[:omf_config_file]
+        puts "Missing config file"
+        abort
+      end
+
+      unless File.readable? cf
+        puts "Can't read config file '#{cf}'"
+        abort
+      end
+
+      @top_dir ||= File.dirname(cf)
+      cfg = _rec_sym_keys(YAML.load_file(cf))
+
+      (cfg[:server] || {}).each do |k, v|
+        k = k.to_sym
+        case k
+        when :port
+          opts[:port] = v.to_i
+        else
+          opts[k] = v
+        end
+      end
+      (cfg[:data_sources] || []).each do |ds|
+        load_datasource(ds)
+      end
+      (cfg[:repositories] || []).each do |repo|
+        load_repository(repo)
+      end
+
+      unless wa = cfg[:widgets]
+        puts "Can't find 'widgets' section in config file '#{cf}' - #{cfg.keys}"
+        abort
+      end
+      wa.each do |w|
+        OMF::Web.register_widget w
+      end
+    end
+
+    def load_datasource(config)
+      unless id = config[:id]
+        puts "Missing id in datasource configuration"
+        abort
+      end
+      case type = config[:type] || 'database'
+      when 'database'
+        load_database(config)
+      when 'file'
+        load_datasource_file(id, config)
+      else
+        abort "Unknown datasource type '#{type}'."
+      end
+    end
+
+    def load_database(config)
+      unless table_name = config[:table]
+        puts "Missing 'table' in datasource configuration '#{id}'"
+        abort
+      end
+      unless db_cfg = config[:database]
+        puts "Missing database configuration in datasource '#{id}'"
+        abort
+      end
+      db = get_database(db_cfg)
+      unless table = db.create_table(table_name)
+        puts "Can't find table '#{table_name}' in database '#{db}'"
+        abort
+      end
+      OMF::Web.register_datasource table, name: id
+    end
+
+    def get_database(config)
+      require 'omf_oml/table'
+      require 'omf_oml/sql_source'
+
+      if config.is_a? String
+        if db = @databases[config]
+          return db
+        end
+        puts "Database '#{config}' not defined - (#{@databases.keys})"
+        abort
+      end
+      unless id = config[:id]
+        puts "Missing id in database configuration"
+        abort
+      end
+      # unless id = config[:id]
+        # puts "Database '#{config}' not defined - (#{@databases.keys})"
+        # abort
+      # end
+      unless url = config[:url]
+        puts "Missing URL for database '#{id}'"
+        abort
+      end
+      if url.start_with?('sqlite://') && ! url.start_with?('sqlite:///')
+        # inject top dir
+        url.insert('sqlite://'.length, @top_dir + '/')
+      end
+      puts "URL: #{url}"
+      begin
+        return @databases[id] = OMF::OML::OmlSqlSource.new(url, :check_interval => 3.0)
+      rescue Exception => ex
+        puts "Can't connect to database '#{id}' - #{ex}"
+        abort
+      end
+    end
+
+    # The data to be served as a datasource is contained in a file. We
+    # currently support CSV with headers, and JSON which turns into a
+    # 1 col by 1 row datasource.
+    #
+    def load_datasource_file(name, opts)
+      unless file = opts[:file]
+        puts "Data source file is not defined in '#{opts}'"
+        abort
+      end
+      unless file.start_with? '/'
+        file = File.join(@top_dir, file)
+      end
+      unless File.readable? file
+        puts "Can't read file '#{file}'"
+        abort
+      end
+      case content_type = opts[:content_type].to_s
+      when 'json'
+        ds = JSONDataSource.new(file)
+      when 'csv'
+        require 'omf_oml/csv_table'
+        ds = OMF::OML::OmlCsvTable.create name, file, has_csv_header: true
+      else
+        puts "Unknown content type '#{content_type}'"
+        abort
+      end
+      OMF::Web.register_datasource ds, name: name
+    end
+
+    def load_repository(config)
+      unless id = config[:id]
+        puts "Missing id in respository configuration"
+        abort
+      end
+      unless type = config[:type]
+        puts "Missing 'type' in respository configuration '#{id}'"
+        abort
+      end
+
+      require 'omf-web/content/repository'
+      case type
+      when 'file'
+        unless top_dir = config[:top_dir]
+          puts "Missing 'top_dir' in respository configuration '#{id}'"
+          abort
+        end
+        unless top_dir.start_with? '/'
+          top_dir = File.join(@top_dir, top_dir)
+        end
+        OMF::Web::ContentRepository.register_repo(id, type: :file, top_dir: top_dir)
+      else
+        puts "Unknown repository type '#{type}'. Only supporting 'file'."
+        abort
+      end
+
+    end
+
+    # Recusively Symbolize keys of hash
+    #
+    def _rec_sym_keys(hash)
+      h = {}
+      hash.each do |k, v|
+        if v.is_a? Hash
+          v = _rec_sym_keys(v)
+        elsif v.is_a? Array
+          v = v.map {|e| e.is_a?(Hash) ? _rec_sym_keys(e) : e }
+        end
+        h[k.to_sym] = v
+      end
+      h
+    end
+
+
+    # This class simulates a DataSource to transfer a JSON file as a database with one row and column
+
+
+    class JSONDataSource < OMF::Common::LObject
+
+      def initialize(file)
+        raw = File.read(file)
+        @content = [[JSON.parse(raw)]]
+      end
+
+      #  * rows Returns an array of rows
+      #  * on_content_changed(lambda{action, rows}) Call provided block with actions :added, :removed
+      #  * create_sliced_table (optional)
+      #  * release Not exactly sure when that is being used
+      #  * schema Schema of row
+      #  * offset
+      def rows
+        @content
+      end
+
+      def offset
+        0
+      end
+
+      def schema
+        require 'omf_oml/schema'
+        OMF::OML::OmlSchema.create([[:content]])
+      end
+
+      def on_content_changed(*args)
+        # do nothing
+      end
+    end
+  end # class
+end # module

data/lib/omf-web/version.rb

@@ -1,7 +1,7 @@
 
 module OMF
   module Web
-    VERSION = '0.9.9'
+    VERSION = '1.0.0'
     # Used for finding the example directory
     TOP_DIR = File.dirname(File.dirname(File.dirname(__FILE__)))
   end

data/lib/omf-web/widget/data_widget.rb

@@ -28,8 +28,8 @@ module OMF::Web::Widget
       opts[:js_url] = "graph/js/#{vizType}.js"
       opts[:js_class] = "OML.#{vizType}"
       opts[:base_el] = "\##{dom_id}"
-      super opts      
-      
+      super opts
+
       if (ds = opts.delete(:data_source))
         # single source
         data_sources = {:default => ds}
@@ -49,10 +49,10 @@ module OMF::Web::Widget
       end
       #puts "DTA_WIDGTE>>> #{opts[:data_sources].inspect}"
     end
-    
-    # This is the DOM id which should be used by the renderer for this widget. 
+
+    # This is the DOM id which should be used by the renderer for this widget.
     # We need to keep this here as various renderes at various levels may need
-    # to get a reference to it to allow for such functionalities as 
+    # to get a reference to it to allow for such functionalities as
     # hiding, stacking, ...
     def dom_id
       "w#{object_id.abs}"
@@ -86,7 +86,7 @@ module OMF::Web::Widget
         # end
       # end
     # end
-# 
+#
     # def on_ws_close(ws)
       # raise "ARE WE STILL NEEDING THIS"
       # @ws = nil