jinx 2.1.1

data/examples/model/ext/src/domain/Parent.java

@@ -0,0 +1,129 @@
+package domain;
+
+import java.util.Collection;
+import java.util.ArrayList;
+
+public class Parent extends DomainObject implements Person
+{
+    /**
+     * A string property.
+     */
+    private String name;
+
+    /**
+     * The parent's spouse.
+     * <p>
+     * This property exercises a 1:1 self-reference.
+     * </p>
+     */
+    private Parent spouse;
+
+    /**
+     * This parent's children.
+     * <p>
+     * This property exercises a reference from an owner to dependents.
+     * </p>
+     */
+    private Collection<Child> children;
+
+    /**
+     * This parent's independent reference.
+     * <p>
+     * This property exercises a reference to an independent object.
+     * </p>
+     */
+    private Independent indy;
+
+    /**
+     * This parent's uni-directional dependent reference.
+     * <p>
+     * This property exercises a reference to a uni-directional dependent object.
+     * </p>
+     */
+    private Dependent dependent;
+
+    public Parent()
+    {
+        children = new ArrayList<Child>();
+    }
+
+    /**
+     * @return the name
+     */
+    public String getName()
+    {
+        return name;
+    }
+
+    /**
+     * @param name the name to set
+     */
+    public void setName(String name)
+    {
+        this.name = name;
+    }
+
+    /**
+     * @return the spouse
+     */
+    public Parent getSpouse()
+    {
+        return spouse;
+    }
+
+    /**
+     * @param spouse the spouse to set
+     */
+    public void setSpouse(Parent spouse)
+    {
+        this.spouse = spouse;
+    }
+
+    /**
+     * @return the children
+     */
+    public Collection<Child> getChildren()
+    {
+        return children;
+    }
+
+    /**
+     * @param children the children to set
+     */
+    public void setChildren(Collection<Child> children)
+    {
+        this.children = children;
+    }
+
+    /**
+     * @return the child independent reference
+     */
+    public Independent getIndy()
+    {
+        return indy;
+    }
+
+    /**
+     * @param indy the child independent reference to set
+     */
+    public void setIndy(Independent indy)
+    {
+        this.indy = indy;
+    }
+    
+    /**
+     * @return the dependent
+     */
+    public Dependent getDependent()
+    {
+        return dependent;
+    }
+
+    /**
+     * @param dependent the dependent to set
+     */
+    public void setDependent(Dependent dependent)
+    {
+        this.dependent = dependent;
+    }
+}

data/examples/model/ext/src/domain/Person.java

@@ -0,0 +1,14 @@
+package domain;
+
+public interface Person
+{
+    /**
+     * @return the name
+     */
+    public String getName();
+
+    /**
+     * @param name the name to set
+     */
+    public void setName(String name);
+}

data/examples/model/lib/model.rb

@@ -0,0 +1,13 @@
+# Add the Java jar file to the Java path.
+require File.dirname(__FILE__) + '/../ext/bin/model.jar'
+
+# The Jinx Model example application domain module.
+module Model
+  include Jinx::Resource
+  
+  # The Java package name.
+  packages 'domain'
+  
+  # The JRuby mix-ins are in the model subdirectory.
+  definitions File.dirname(__FILE__) + '/model'
+end

data/examples/model/lib/model/child.rb

@@ -0,0 +1,13 @@
+module Model
+  class Child
+    # The friends property has a pals 
+    property :friends, :alias => :pals
+    
+    # The default cardinal value is 1.
+    property :cardinal, :default => 1
+    
+    # The secondary key is the name scoped by the parent.
+    property :parent, :secondary_key
+    property :name, :secondary_key
+  end
+end

data/examples/model/lib/model/domain_object.rb

@@ -0,0 +1,6 @@
+module Model
+  class DomainObject
+    # The identifier property is the primary key.
+    property :identifier, :primary_key
+  end
+end

data/examples/model/lib/model/independent.rb

@@ -0,0 +1,11 @@
+module Model
+  class Independent
+    # The others property is a M:N association without a parameterized type.
+    # Specify the type here, since it cannot be introspected. The inverse
+    # of a source object is the target object others property value.
+    property :others, :type => self, :inverse => :others
+    
+    # The secondary key is the name.
+    property :name, :secondary_key
+  end
+end

data/examples/model/lib/model/parent.rb

@@ -0,0 +1,17 @@
+module Model
+  class Parent
+    # A parent owns children.
+    property :children, :dependent
+    
+    # The parent dependent attribute references a Dependent. The dependent
+    # attribute is, not surprisingly, designated as a dependent reference.
+    property :dependent, :dependent
+    
+    # The spouse is an independent reference. The spouse is an idempotent inverse,
+    # i.e. parent = parent.spouse.spouse.
+    property :spouse, :inverse => :spouse
+    
+    # The secondary key is the name.
+    property :name, :secondary_key
+  end
+end

data/jinx.gemspec

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/lib/jinx/version'
+require 'date'
+
+Gem::Specification.new do |s|
+  s.name          = 'jinx'
+  s.summary       = 'Jruby INtrospeXion facade.'
+  s.description   = s.summary + '. See github.com/jinx/core for more information.'
+  s.version       = Jinx::VERSION
+  s.date          = Date.today
+  s.author        = 'OHSU'
+  s.email         = 'jinx.ruby@gmail.com'
+  s.homepage      = 'http://github.com/jinx/core'
+  s.require_path  = 'lib'
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files test`.split("\n")
+  s.add_runtime_dependency     'bundler'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec', '>= 2.6'
+  s.has_rdoc      = 'yard'
+  s.license       = 'MIT'
+  s.rubyforge_project = 'caruby'
+end

data/lib/jinx.rb

@@ -0,0 +1,3 @@
+require 'jinx/helpers/log'
+require 'jinx/helpers/error'
+require 'jinx/resource'

data/lib/jinx/active_support/README.txt

@@ -0,0 +1,2 @@
+The files in this directory are shamelessly stolen from Rails. They are included here rather than pulled in as a gem
+in order to avoid a dependency on the entire Rails project for a limited utility.

data/lib/jinx/active_support/core_ext/string.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+require 'active_support/core_ext/string/inflections'
+
+class String #:nodoc:
+  include ActiveSupport::CoreExtensions::String::Inflections
+end

data/lib/jinx/active_support/core_ext/string/inflections.rb

@@ -0,0 +1,167 @@
+require 'jinx/active_support/inflector'
+
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      # String inflections define new methods on the String class to transform names for different purposes.
+      # For instance, you can figure out the name of a database from the name of a class.
+      #
+      #   "ScaleScore".tableize #=>"scale_scores"
+      module Inflections
+        # Returns the plural form of the word in the string.
+        #
+        #   "post".pluralize             #=>"posts"
+        #   "octopus".pluralize          #=>"octopi"
+        #   "sheep".pluralize            #=>"sheep"
+        #   "words".pluralize            #=>"words"
+        #   "the blue mailman".pluralize #=>"the blue mailmen"
+        #   "CamelOctopus".pluralize     #=>"CamelOctopi"
+        def pluralize
+          Inflector.pluralize(self)
+        end
+
+        # The reverse of +pluralize+, returns the singular form of a word in a string.
+        #
+        #   "posts".singularize            #=>"post"
+        #   "octopi".singularize           #=>"octopus"
+        #   "sheep".singularize            #=>"sheep"
+        #   "word".singularize             #=>"word"
+        #   "the blue mailmen".singularize #=>"the blue mailman"
+        #   "CamelOctopi".singularize      #=>"CamelOctopus"
+        def singularize
+          Inflector.singularize(self)
+        end
+
+        # By default, +camelize+ converts strings to UpperCamelCase. If the argument to camelize
+        # is set to <tt>:lower</tt> then camelize produces lowerCamelCase.
+        #
+        # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
+        #
+        #   "active_record".camelize                #=>"ActiveRecord"
+        #   "active_record".camelize(:lower)        #=>"activeRecord"
+        #   "active_record/errors".camelize         #=>"ActiveRecord::Errors"
+        #   "active_record/errors".camelize(:lower) #=>"activeRecord::Errors"
+        def camelize(first_letter = :upper)
+          case first_letter
+            when :upper then Inflector.camelize(self, true)
+            when :lower then Inflector.camelize(self, false)
+          end
+        end
+        alias_method :camelcase, :camelize
+
+        # Capitalizes all the words and replaces some characters in the string to create
+        # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
+        # used in the Rails internals.
+        #
+        # +titleize+ is also aliased as +titlecase+.
+        #
+        #   "man from the boondocks".titleize #=>"Man From The Boondocks"
+        #   "x-men: the last stand".titleize  #=>"X Men: The Last Stand"
+        def titleize
+          Inflector.titleize(self)
+        end
+        alias_method :titlecase, :titleize
+
+        # The reverse of +camelize+. Makes an underscored, lowercase form from the expression in the string.
+        # 
+        # +underscore+ will also change '::' to '/' to convert namespaces to paths.
+        #
+        #   "ActiveRecord".underscore         #=>"active_record"
+        #   "ActiveRecord::Errors".underscore #=>active_record/errors
+        def underscore
+          Inflector.underscore(self)
+        end
+
+        # Replaces underscores with dashes in the string.
+        #
+        #   "puni_puni" #=>"puni-puni"
+        def dasherize
+          Inflector.dasherize(self)
+        end
+
+        # Removes the module part from the constant expression in the string.
+        #
+        #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize #=>"Inflections"
+        #   "Inflections".demodulize                                       #=>"Inflections"
+        def demodulize
+          Inflector.demodulize(self)
+        end
+
+        # Replaces special characters in a string so that it may be used as part of a 'pretty' URL.
+        # 
+        # ==== Examples
+        #
+        #   class Person
+        #     def to_param
+        #       "#{id}-#{name.parameterize}"
+        #     end
+        #   end
+        # 
+        #   @person = Person.find(1)
+        #   #=>#<Person id: 1, name: "Donald E. Knuth">
+        # 
+        #   <%= link_to(@person.name, person_path %>
+        #   #=><a href="/person/1-donald-e-knuth">Donald E. Knuth</a>
+        def parameterize
+          Inflector.parameterize(self)
+        end
+
+        # Creates the name of a table like Rails does for models to table names. This method
+        # uses the +pluralize+ method on the last word in the string.
+        #
+        #   "RawScaledScorer".tableize #=>"raw_scaled_scorers"
+        #   "egg_and_ham".tableize     #=>"egg_and_hams"
+        #   "fancyCategory".tableize   #=>"fancy_categories"
+        def tableize
+          Inflector.tableize(self)
+        end
+
+        # Create a class name from a plural table name like Rails does for table names to models.
+        # Note that this returns a string and not a class. (To convert to an actual class
+        # follow +classify+ with +constantize+.)
+        #
+        #   "egg_and_hams".classify #=>"EggAndHam"
+        #   "posts".classify        #=>"Post"
+        #
+        # Singular names are not handled correctly.
+        #
+        #   "business".classify #=>"Busines"
+        def classify
+          Inflector.classify(self)
+        end
+
+        # Capitalizes the first word, turns underscores into spaces, and strips '_id'.
+        # Like +titleize+, this is meant for creating pretty output.
+        #
+        #   "employee_salary" #=>"Employee salary" 
+        #   "author_id"       #=>"Author"
+        def humanize
+          Inflector.humanize(self)
+        end
+
+        # Creates a foreign key name from a class name.
+        # +separate_class_name_and_id_with_underscore+ sets whether
+        # the method should put '_' between the name and 'id'.
+        #
+        # Examples
+        #   "Message".foreign_key        #=>"message_id"
+        #   "Message".foreign_key(false) #=>"messageid"
+        #   "Admin::Post".foreign_key    #=>"post_id"
+        def foreign_key(separate_class_name_and_id_with_underscore = true)
+          Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
+        end
+
+        # +constantize+ tries to find a declared constant with the name specified
+        # in the string. It raises a NameError when the name is not in CamelCase
+        # or is not initialized.
+        #
+        # Examples
+        #   "Module".constantize #=>Module
+        #   "Class".constantize  #=>Class
+        def constantize
+          Inflector.constantize(self)
+        end
+      end
+    end
+  end
+end

data/lib/jinx/active_support/inflections.rb

@@ -0,0 +1,55 @@
+module ActiveSupport
+  Inflector.inflections do |inflect|
+    inflect.plural(/$/, 's')
+    inflect.plural(/s$/i, 's')
+    inflect.plural(/(ax|test)is$/i, '\1es')
+    inflect.plural(/(octop|vir)us$/i, '\1i')
+    inflect.plural(/(alias|status)$/i, '\1es')
+    inflect.plural(/(bu)s$/i, '\1ses')
+    inflect.plural(/(buffal|tomat)o$/i, '\1oes')
+    inflect.plural(/([ti])um$/i, '\1a')
+    inflect.plural(/sis$/i, 'ses')
+    inflect.plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+    inflect.plural(/(hive)$/i, '\1s')
+    inflect.plural(/([^aeiouy]|qu)y$/i, '\1ies')
+    inflect.plural(/(x|ch|ss|sh)$/i, '\1es')
+    inflect.plural(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices')
+    inflect.plural(/([m|l])ouse$/i, '\1ice')
+    inflect.plural(/^(ox)$/i, '\1en')
+    inflect.plural(/(quiz)$/i, '\1zes')
+
+    inflect.singular(/s$/i, '')
+    inflect.singular(/(n)ews$/i, '\1ews')
+    inflect.singular(/([ti])a$/i, '\1um')
+    inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis')
+    inflect.singular(/(^analy)ses$/i, '\1sis')
+    inflect.singular(/([^f])ves$/i, '\1fe')
+    inflect.singular(/(hive)s$/i, '\1')
+    inflect.singular(/(tive)s$/i, '\1')
+    inflect.singular(/([lr])ves$/i, '\1f')
+    inflect.singular(/([^aeiouy]|qu)ies$/i, '\1y')
+    inflect.singular(/(s)eries$/i, '\1eries')
+    inflect.singular(/(m)ovies$/i, '\1ovie')
+    inflect.singular(/(x|ch|ss|sh)es$/i, '\1')
+    inflect.singular(/([m|l])ice$/i, '\1ouse')
+    inflect.singular(/(bus)es$/i, '\1')
+    inflect.singular(/(o)es$/i, '\1')
+    inflect.singular(/(shoe)s$/i, '\1')
+    inflect.singular(/(cris|ax|test)es$/i, '\1is')
+    inflect.singular(/(octop|vir)i$/i, '\1us')
+    inflect.singular(/(alias|status)es$/i, '\1')
+    inflect.singular(/^(ox)en/i, '\1')
+    inflect.singular(/(vert|ind)ices$/i, '\1ex')
+    inflect.singular(/(matr)ices$/i, '\1ix')
+    inflect.singular(/(quiz)zes$/i, '\1')
+
+    inflect.irregular('person', 'people')
+    inflect.irregular('man', 'men')
+    inflect.irregular('child', 'children')
+    inflect.irregular('sex', 'sexes')
+    inflect.irregular('move', 'moves')
+    inflect.irregular('cow', 'kine')
+
+    inflect.uncountable(%w(equipment information rice money species series fish sheep))
+  end
+end