glimmer 0.8.1 → 0.9.3

data/lib/glimmer/dsl/xml/meta_expression.rb

@@ -1,23 +0,0 @@
-require 'glimmer/dsl/xml/node_parent_expression'
-require 'glimmer/dsl/xml/xml_expression'
-require 'glimmer/dsl/static_expression'
-
-module Glimmer
-  module DSL
-    module XML
-      # This static html expression flips the DSL switch on for 
-      # XML DSL in Glimmer
-      class MetaExpression < StaticExpression
-        include NodeParentExpression
-
-        def interpret(parent, keyword, *args, &block)
-          xml_expression.interpret(parent, keyword, *args, &block)
-        end
-
-        def xml_expression
-          @xml_expression ||= XmlExpression.new
-        end
-      end
-    end
-  end
-end

data/lib/glimmer/dsl/xml/name_space_expression.rb

@@ -1,37 +0,0 @@
-require 'glimmer/dsl/static_expression'
-require 'glimmer/dsl/top_level_expression'
-require 'glimmer/xml/node'
-require 'glimmer/xml/depth_first_search_iterator'
-require 'glimmer/xml/name_space_visitor'
-
-module Glimmer
-  module DSL
-    module XML
-      class NameSpaceExpression < StaticExpression
-        include TopLevelExpression
-
-        def can_interpret?(parent, keyword, *args, &block)
-          (parent == nil or parent.is_a?(Glimmer::XML::Node)) and
-          (keyword.to_s == "name_space")
-          (args.size == 1) and
-          (args[0].is_a?(Symbol)) and
-          block
-        end
-
-        def interpret(parent, keyword, *args, &block)
-          node = block.call
-          unless node.is_a?(String)
-            name_space_visitor = Glimmer::XML::NameSpaceVisitor.new(args[0].to_s)
-            Glimmer::XML::DepthFirstSearchIterator.new(node, name_space_visitor).iterate
-            def node.process_block(block)
-              Glimmer::Config.logger&.debug 'block'
-              #NOOP
-            end
-          end
-          parent.children << node if parent and !parent.children.include?(node)
-          node
-        end
-      end
-    end
-  end
-end

data/lib/glimmer/dsl/xml/node_parent_expression.rb

@@ -1,33 +0,0 @@
-require 'glimmer'
-require 'glimmer/dsl/parent_expression'
-require 'glimmer/xml/node'
-
-module Glimmer
-  module DSL
-    module XML
-      module NodeParentExpression
-        include ParentExpression
-        include Glimmer
-
-        def add_content(parent, &block)
-          return_value = block.call(parent)      
-          if !return_value.is_a?(Glimmer::XML::Node) and !parent.children.include?(return_value)
-            text = return_value.to_s
-            first_match = text.match(/[#][^{]+[{][^}]+[}]/)
-            match = first_match
-            while (match)
-              instance_eval(parent.text_command(match.pre_match))
-              tag_text = match.to_s
-              instance_eval(parent.rubyize(tag_text))
-              text = tag_text
-              post_match = match.post_match
-              match = text.match(/[#]\w+[{]\w+[}]/)
-            end
-            instance_eval(parent.text_command(post_match)) if post_match
-            parent.children << return_value unless first_match
-          end
-        end
-      end
-    end
-  end
-end

data/lib/glimmer/dsl/xml/tag_expression.rb

@@ -1,29 +0,0 @@
-require 'glimmer/dsl/xml/node_parent_expression'
-require 'glimmer/dsl/xml/xml_expression'
-require 'glimmer/dsl/static_expression'
-require 'glimmer/dsl/top_level_expression'
-require 'glimmer/xml/node'
-
-module Glimmer
-  module DSL
-    module XML
-      class TagExpression < StaticExpression
-        include TopLevelExpression
-        include NodeParentExpression
-
-        def can_interpret?(parent, keyword, *args, &block)
-          (parent == nil or parent.is_a?(Glimmer::XML::Node)) and
-          (keyword.to_s == "tag") and
-            args[0].include?(:_name)
-        end
-
-        def interpret(parent, keyword, *args, &block)
-          attributes = args[0] if (args.size == 1)
-          tag_name = attributes[:_name]
-          attributes.delete(:_name)
-          Glimmer::XML::Node.new(parent, tag_name, attributes, &block)
-        end
-      end
-    end
-  end
-end

data/lib/glimmer/dsl/xml/text_expression.rb

@@ -1,22 +0,0 @@
-require 'glimmer/dsl/static_expression'
-require 'glimmer/xml/node'
-
-module Glimmer
-  module DSL
-    module XML
-      class TextExpression < StaticExpression
-        def can_interpret?(parent, keyword, *args, &block)
-          (parent == nil or parent.is_a?(Glimmer::XML::Node)) and
-          (keyword.to_s == "text") and
-          (args.size == 1) and
-          !block
-        end
-
-        def interpret(parent, keyword, *args, &block)
-          parent.children << args[0].to_s if parent
-          args[0].to_s
-        end
-      end
-    end
-  end
-end

data/lib/glimmer/dsl/xml/xml_expression.rb

@@ -1,21 +0,0 @@
-require 'glimmer/dsl/xml/node_parent_expression'
-require 'glimmer/dsl/expression'
-require 'glimmer/xml/node'
-
-module Glimmer
-  module DSL
-    module XML
-      class XmlExpression < Expression
-        include NodeParentExpression
-
-        def can_interpret?(parent, keyword, *args, &block)
-          parent.is_a?(Glimmer::XML::Node)
-        end
-
-        def interpret(parent, keyword, *args, &block)
-          Glimmer::XML::Node.new(parent, keyword.to_s, args, &block)
-        end
-      end
-    end
-  end
-end

data/lib/glimmer/launcher.rb

@@ -1,199 +0,0 @@
-require 'os'
-require 'rake'
-
-require_relative 'rake_task'
-
-module Glimmer
-  class Launcher
-    OPERATING_SYSTEMS_SUPPORTED = ["mac", "windows", "linux"]
-    
-    TEXT_USAGE_PREFIX = <<~MULTI_LINE_STRING
-      Usage: glimmer [--quiet] [--debug] [--log-level=VALUE] [[ENV_VAR=VALUE]...] [[-jruby-option]...] (application.rb or task[task_args]) [[application2.rb]...]
-    
-      Runs Glimmer applications/tasks.
-    
-      Either a single task or one or more applications may be specified.
-    
-      When a task is specified, it runs via rake. Some tasks take arguments in square brackets.
-    
-      Available tasks are below (you may also lookup by adding `require 'glimmer/rake_task'` in Rakefile and running rake -T):
-    MULTI_LINE_STRING
-
-    TEXT_USAGE_SUFFIX = <<~MULTI_LINE_STRING
-    
-      When applications are specified, they are run using JRuby, 
-      automatically preloading the glimmer Ruby gem and SWT jar dependency.
-    
-      Optionally, extra Glimmer options, JRuby options and environment variables may be passed in.
-    
-      Glimmer options:
-      - "--quiet"           : Does not announce file path of Glimmer application being launched
-      - "--debug"           : Displays extra debugging information, passes "--debug" to JRuby, and enables debug logging
-      - "--log-level=VALUE" : Sets Glimmer's Ruby logger level ("ERROR" / "WARN" / "INFO" / "DEBUG"; default is none)
-    
-      Example: glimmer samples/hello_world.rb
-    
-      This runs the Glimmer application samples/hello_world.rb
-    MULTI_LINE_STRING
-
-    GLIMMER_LIB_LOCAL = File.expand_path(File.join(__FILE__, '..', '..', 'glimmer.rb'))
-    GLIMMER_LIB_GEM = 'glimmer'
-    GLIMMER_OPTIONS = %w[--log-level --quiet]
-    GLIMMER_OPTION_ENV_VAR_MAPPING = {
-      '--log-level' => 'GLIMMER_LOGGER_LEVEL'
-    }
-    REGEX_RAKE_TASK_WITH_ARGS = /^([^\[]+)\[?([^\]]*)\]?$/
-
-    @@mutex = Mutex.new
-
-    class << self
-      def platform_os
-        OPERATING_SYSTEMS_SUPPORTED.detect {|os| OS.send("#{os}?")}
-      end
-
-      def swt_jar_file
-        @swt_jar_file ||= File.expand_path(File.join(__FILE__, '..', '..', '..', 'vendor', 'swt', platform_os, 'swt.jar'))
-      end
-
-      def jruby_os_specific_options
-        OS.mac? ? "-J-XstartOnFirstThread" : ""
-      end
-
-      def jruby_swt_options
-        "#{jruby_os_specific_options} -J-classpath \"#{swt_jar_file}\""
-      end
-
-      def glimmer_lib
-        @@mutex.synchronize do
-          unless @glimmer_lib
-            @glimmer_lib = GLIMMER_LIB_GEM
-            glimmer_gem_listing = `jgem list #{GLIMMER_LIB_GEM}`.split("\n").map {|l| l.split.first}
-            if !glimmer_gem_listing.include?(GLIMMER_LIB_GEM) && File.exists?(GLIMMER_LIB_LOCAL)
-              @glimmer_lib = GLIMMER_LIB_LOCAL
-              puts "[DEVELOPMENT MODE] (detected #{@glimmer_lib})"
-            end
-          end
-        end
-        @glimmer_lib
-      end
-
-      def glimmer_option_env_vars(glimmer_options)
-        GLIMMER_OPTION_ENV_VAR_MAPPING.reduce({}) do |hash, pair|
-          glimmer_options[pair.first] ? hash.merge(GLIMMER_OPTION_ENV_VAR_MAPPING[pair.first] => glimmer_options[pair.first]) : hash
-        end
-      end
-
-      def load_env_vars(env_vars)
-        env_vars.each do |key, value|
-          ENV[key] = value
-        end
-      end
-
-      def launch(application, jruby_options: [], env_vars: {}, glimmer_options: {})
-        jruby_options_string = jruby_options.join(' ') + ' ' if jruby_options.any?
-        env_vars = env_vars.merge(glimmer_option_env_vars(glimmer_options))
-        env_vars_string = env_vars.map {|k,v| "#{k}=#{v}"}.join(' ')
-        the_glimmer_lib = glimmer_lib
-        devmode_require = nil
-        if the_glimmer_lib == GLIMMER_LIB_LOCAL
-          devmode_require = '-r puts_debuggerer '
-        end
-        rake_tasks = Rake.application.tasks.map(&:to_s).map {|t| t.sub('glimmer:', '')}
-        potential_rake_task_parts = application.match(REGEX_RAKE_TASK_WITH_ARGS)
-        application = potential_rake_task_parts[1]
-        rake_task_args = potential_rake_task_parts[2].split(',')
-        if rake_tasks.include?(application)
-          load_env_vars(glimmer_option_env_vars(glimmer_options))
-          rake_task = "glimmer:#{application}"
-          puts "Running Glimmer rake task: #{rake_task}" if jruby_options_string.to_s.include?('--debug')
-          Rake::Task[rake_task].invoke(*rake_task_args)
-        else
-          @@mutex.synchronize do
-            puts "Launching Glimmer Application: #{application}" if jruby_options_string.to_s.include?('--debug') || glimmer_options['--quiet'].to_s.downcase != 'true'
-          end
-          command = "#{env_vars_string} jruby #{jruby_options_string}#{jruby_os_specific_options} #{devmode_require}-r #{the_glimmer_lib} -S #{application}"
-          puts command if jruby_options_string.to_s.include?('--debug')
-          system command
-        end
-      end
-    end
-    
-    attr_reader :application_paths
-    attr_reader :env_vars
-    attr_reader :glimmer_options
-    attr_reader :jruby_options
-
-    def initialize(raw_options)
-      raw_options << '--quiet' if !caller.join("\n").include?('/bin/glimmer:') && !raw_options.join.include?('--quiet=')
-      raw_options << '--log-level=DEBUG' if raw_options.join.include?('--debug') && !raw_options.join.include?('--log-level=')
-      @application_paths = extract_application_paths(raw_options)
-      @env_vars = extract_env_vars(raw_options)
-      @glimmer_options = extract_glimmer_options(raw_options)
-      @jruby_options = raw_options
-    end
-
-    def launch
-      if @application_paths.empty?
-        display_usage
-      else
-        launch_application
-      end
-    end
-
-    private
-
-    def launch_application
-      load File.expand_path('./Rakefile') if File.exist?(File.expand_path('./Rakefile')) && caller.join("\n").include?('/bin/glimmer:')
-      threads = @application_paths.map do |application_path|
-        Thread.new do
-          self.class.launch(
-            application_path,
-            jruby_options: @jruby_options,
-            env_vars: @env_vars,
-            glimmer_options: @glimmer_options
-          )
-        end
-      end
-      threads.each(&:join)
-    end
-
-    def display_usage
-      rake_tasks = `rake -T`.gsub('rake glimmer:', 'glimmer ').split("\n").select {|l| l.start_with?('glimmer ')}
-      puts TEXT_USAGE_PREFIX
-      puts rake_tasks.join("\n")
-      puts TEXT_USAGE_SUFFIX
-    end
-
-    def extract_application_paths(options)
-      options.select do |option|
-        !option.start_with?('-') && !option.include?('=')
-      end.each do |application_path|
-        options.delete(application_path)
-      end
-    end
-
-    def extract_env_vars(options)
-      options.select do |option|
-        !option.start_with?('-') && option.include?('=')
-      end.each do |env_var|
-        options.delete(env_var)
-      end.reduce({}) do |hash, env_var_string|
-        match = env_var_string.match(/^([^=]+)=(.+)$/)
-        hash.merge(match[1] => match[2])
-      end
-    end
-
-    def extract_glimmer_options(options)
-      options.select do |option|
-        GLIMMER_OPTIONS.reduce(false) do |result, glimmer_option|
-          result || option.include?(glimmer_option)
-        end
-      end.each do |glimmer_option|
-        options.delete(glimmer_option)
-      end.reduce({}) do |hash, glimmer_option_string|
-        match = glimmer_option_string.match(/^([^=]+)=?(.+)?$/)
-        hash.merge(match[1] => (match[2] || 'true'))
-      end
-    end
-  end
-end

data/lib/glimmer/package.rb

@@ -1,7 +0,0 @@
-module Glimmer
-  module Package
-    class << self
-      attr_accessor :javapackager_extra_args
-    end
-  end
-end

data/lib/glimmer/rake_task.rb

@@ -1,89 +0,0 @@
-require 'rake'
-
-require_relative 'package'
-require_relative 'scaffold'
-
-namespace :glimmer do
-  namespace :package do
-    desc 'Generate JAR config file'
-    task :config do
-      project_name = File.basename(File.expand_path('.'))
-      if !File.exists?('config/warble.rb')
-        puts 'Generating JAR configuration (config/warble.rb) to use with Warbler...'
-        system('mkdir -p config')
-        system('warble config')
-        new_config = File.read('config/warble.rb').split("\n").inject('') do |output, line|
-          if line.include?('config.dirs =')
-            line = line.sub('# ', '').sub(/=[^=\n]+$/, '= %w(app config db lib script bin docs fonts icons images sounds videos)')
-          end
-          if line.include?('config.includes =')
-            line = line.sub('# ', '').sub(/=[^=\n]+$/, "= FileList['LICENSE.txt', 'VERSION']")
-          end
-          if line.include?('config.autodeploy_dir =')
-            line = line.sub('# ', '')
-          end
-          output + "\n" + line
-        end
-        File.write('config/warble.rb', new_config)
-      end
-    end
-
-    desc 'Generate JAR file'
-    task :jar => 'package:config' do
-      system('mkdir -p dist')
-      puts "Generating JAR with Warbler..."
-      system('warble')
-    end
-
-    desc 'Generate Native files (DMG/PKG/APP on the Mac)'
-    task :native => 'package:jar' do
-      require 'facets/string/titlecase'
-      require 'facets/string/underscore'
-      project_name = File.basename(File.expand_path('.'))
-      version_file = File.expand_path('./VERSION')
-      version = (File.read(version_file).strip if File.exists?(version_file) && File.file?(version_file)) rescue nil
-      license_file = File.expand_path('./LICENSE.txt')
-      license = (File.read(license_file).strip if File.exists?(license_file) && File.file?(license_file)) rescue nil
-      human_name = project_name.underscore.titlecase
-      command = "javapackager -deploy -native -outdir packages -outfile \"#{project_name}\" -srcfiles \"dist/#{project_name}.jar\" -appclass JarMain -name \"#{human_name}\" -title \"#{human_name}\" -BjvmOptions=-XstartOnFirstThread -Bmac.CFBundleName=\"#{human_name}\" -Bmac.CFBundleIdentifier=\"org.#{project_name}.application.#{project_name}\" -Bmac.category=\"public.app-category.business\" "
-      command += " -BappVersion=#{version} -Bmac.CFBundleVersion=#{version} " if version
-      command += " -srcfiles LICENSE.txt -BlicenseFile=LICENSE.txt " if license
-      command += " #{Glimmer::Package.javapackager_extra_args} " if Glimmer::Package.javapackager_extra_args
-      command += " #{ENV['JAVAPACKAGER_EXTRA_ARGS']} " if ENV['JAVAPACKAGER_EXTRA_ARGS']
-      puts "Generating DMG/PKG/APP/JNLP with javapackager..."
-      puts command
-      system command
-    end
-  end
-
-  desc 'Package app for distribution (generating config, jar, and native files)'
-  task :package => 'package:native'
-
-
-  desc 'Scaffold a Glimmer application directory structure to begin building a new app'
-  task :scaffold, [:app_name] do |t, args|
-    Scaffold.app(args[:app_name])
-  end
-
-  namespace :scaffold do
-    desc 'Scaffold a Glimmer::UI::CustomShell subclass (represents a full window view) under app/views (namespace is optional)'
-    task :custom_shell, [:custom_shell_name, :namespace] do |t, args|
-      Scaffold.custom_shell(args[:custom_shell_name], args[:namespace])
-    end
-    
-    desc 'Scaffold a Glimmer::UI::CustomWidget subclass (represents a part of a view) under app/views (namespace is optional)'
-    task :custom_widget, [:custom_widget_name, :namespace] do |t, args|
-      Scaffold.custom_widget(args[:custom_widget_name], args[:namespace])
-    end
-    
-    desc 'Scaffold a Glimmer::UI::CustomShell subclass (represents a full window view) under its own Ruby gem + app project (namespace is required)'
-    task :custom_shell_gem, [:custom_shell_name, :namespace] do |t, args|
-      Scaffold.custom_shell_gem(args[:custom_shell_name], args[:namespace])
-    end
-    
-    desc 'Scaffold a Glimmer::UI::CustomWidget subclass (represents a part of a view) under its own Ruby gem project (namespace is required)'
-    task :custom_widget_gem, [:custom_widget_name, :namespace] do |t, args|
-      Scaffold.custom_widget_gem(args[:custom_widget_name], args[:namespace])
-    end
-  end
-end