killbill 1.0.15 → 1.0.16

data/spec/killbill/base_plugin_spec.rb

@@ -15,6 +15,7 @@ class LifecycleNotificationPlugin < Killbill::Plugin::PluginBase
 end
 
 describe Killbill::Plugin::PluginBase do
+=begin
   it 'should be able to register Killbill API instances' do
     plugin = Killbill::Plugin::PluginBase.new(:account_user_api => MockAccountUserApi.new)
 
@@ -28,7 +29,7 @@ describe Killbill::Plugin::PluginBase do
     # Default method missing behavior
     lambda { plugin.blablabla }.should raise_error NoMethodError
   end
-
+=end
   it 'should be able to default to the ruby logger for tests' do
     logger = Logger.new(STDOUT)
     logger.level = Logger::DEBUG

data/spec/killbill/{jresponse/jconverter_spec.rb → jconverter_spec.rb}

@@ -1,17 +1,6 @@
 require 'spec_helper'
 require 'date'
-
-require 'killbill/response/payment_method_response'
-require 'killbill/response/payment_method_response_internal'
-require 'killbill/response/payment_status'
-require 'killbill/response/payment_response'
-require 'killbill/response/refund_response'
-require 'killbill/response/event'
-
-require 'killbill/jresponse/jconverter'
-require 'killbill/jresponse/jpayment_method_response'
-require 'killbill/jresponse/jpayment_method_response_internal'
-require 'killbill/jresponse/jevent'
+require 'killbill/jconverter'
 
 describe Killbill::Plugin::JConverter do
 
@@ -38,25 +27,32 @@ describe Killbill::Plugin::JConverter do
       output.should == input
     end
 
+    it "should_test_to_string_converter_from_non_string" do
+      input = 12
+      output = Killbill::Plugin::JConverter.to_string(input)
+      output.should be_an_instance_of java.lang.String
+      output.should == input.to_s
+    end
+
     it "should_test_payment_plugin_status_success_converter" do
-      input = Killbill::Plugin::PaymentStatus::SUCCESS
+      input = Killbill::Plugin::Model::PaymentPluginStatus.new(:PROCESSED)
       output = Killbill::Plugin::JConverter.to_payment_plugin_status(input)
-      output.should be_an_instance_of Java::com.ning.billing.payment.plugin.api.PaymentInfoPlugin::PaymentPluginStatus
-      output.should == Java::com.ning.billing.payment.plugin.api.PaymentInfoPlugin::PaymentPluginStatus::PROCESSED
+      output.should be_an_instance_of Java::com.ning.billing.payment.plugin.api.PaymentPluginStatus
+      output.should == Java::com.ning.billing.payment.plugin.api.PaymentPluginStatus::PROCESSED
     end
 
     it "should_test_payment_plugin_status_failed_converter" do
-      input = Killbill::Plugin::PaymentStatus::ERROR
+      input = Killbill::Plugin::Model::PaymentPluginStatus.new(:ERROR)
       output = Killbill::Plugin::JConverter.to_payment_plugin_status(input)
-      output.should be_an_instance_of Java::com.ning.billing.payment.plugin.api.PaymentInfoPlugin::PaymentPluginStatus
-      output.should == Java::com.ning.billing.payment.plugin.api.PaymentInfoPlugin::PaymentPluginStatus::ERROR
+      output.should be_an_instance_of Java::com.ning.billing.payment.plugin.api.PaymentPluginStatus
+      output.should == Java::com.ning.billing.payment.plugin.api.PaymentPluginStatus::ERROR
     end
 
     it "should_test_payment_plugin_status_undefined_converter" do
-      input = Killbill::Plugin::PaymentStatus::UNDEFINED
+      input = Killbill::Plugin::Model::PaymentPluginStatus.new(:UNDEFINED)
       output = Killbill::Plugin::JConverter.to_payment_plugin_status(input)
-      output.should be_an_instance_of Java::com.ning.billing.payment.plugin.api.PaymentInfoPlugin::PaymentPluginStatus
-      output.should == Java::com.ning.billing.payment.plugin.api.PaymentInfoPlugin::PaymentPluginStatus::UNDEFINED
+      output.should be_an_instance_of Java::com.ning.billing.payment.plugin.api.PaymentPluginStatus
+      output.should == Java::com.ning.billing.payment.plugin.api.PaymentPluginStatus::UNDEFINED
     end
 
     it "should_test_big_decimal_converter" do
@@ -68,7 +64,7 @@ describe Killbill::Plugin::JConverter do
         12376 => '12.376',
         -532 => '-5.32'
       }.each do |input,output|
-        output = Killbill::Plugin::JConverter.to_big_decimal(input)
+        output = Killbill::Plugin::JConverter.to_big_decimal_with_cents_conversion(input)
         output.should be_an_instance_of java.math.BigDecimal
         output.to_s.should == output.to_s
       end
@@ -91,7 +87,7 @@ describe Killbill::Plugin::JConverter do
     it "should_test_uuid_from_converter" do
       input = java.util.UUID.random_uuid
       output = Killbill::Plugin::JConverter.from_uuid(input)
-      output.should be_an_instance_of String
+      output.should be_an_instance_of Killbill::Plugin::Model::UUID
       output.to_s.should == input.to_s
     end
 
@@ -117,7 +113,6 @@ describe Killbill::Plugin::JConverter do
       output.to_s == "false"
     end
 
-
     it "should_test_boolean_from_true_converter" do
       input = java.lang.Boolean.new("true")
       output = Killbill::Plugin::JConverter.from_boolean(input)
@@ -144,94 +139,55 @@ describe Killbill::Plugin::JConverter do
     end
 
     it "should_test_payment_status_from_converter" do
-      input = Java::com.ning.billing.payment.plugin.api.PaymentInfoPlugin::PaymentPluginStatus::PROCESSED
+      input = Java::com.ning.billing.payment.plugin.api.PaymentPluginStatus::PROCESSED
       output = Killbill::Plugin::JConverter.from_payment_plugin_status(input)
-      output.should == Killbill::Plugin::PaymentStatus::SUCCESS
+      output.should == Killbill::Plugin::Model::PaymentPluginStatus.new(:PROCESSED)
     end
 
     it "should_test_big_decimal_from_converter" do
       input = java.math.BigDecimal::TEN
-      output = Killbill::Plugin::JConverter.from_big_decimal(input)
+      output = Killbill::Plugin::JConverter.from_big_decimal_with_cents_conversion(input)
       output.should be_an_instance_of Fixnum
       output.to_s.should == "1000"
     end
 
-    it "should_test_payment_method_plugin_from_converter" do
-      prop = Killbill::Plugin::PaymentMethodProperty.new("key", "value", true)
-      payment_method_response = Killbill::Plugin::PaymentMethodResponse.new("external_payment_method_id", true, [prop])
-      input = Killbill::Plugin::JPaymentMethodResponse.new(payment_method_response)
-      output = Killbill::Plugin::JConverter.from_payment_method_plugin(input)
-
-      output.should be_an_instance_of Killbill::Plugin::PaymentMethodResponse
-
-      output.external_payment_method_id.should be_an_instance_of String
-      output.external_payment_method_id.should == payment_method_response.external_payment_method_id
-
-      output.is_default.should be_an_instance_of TrueClass
-      output.is_default.should == payment_method_response.is_default
-
-      output.properties.should be_an_instance_of Array
-      output.properties.size.should == 1
-
-      output_prop = output.properties[0]
-      output_prop.should be_an_instance_of Killbill::Plugin::PaymentMethodProperty
-
-      output_prop.key.should be_an_instance_of String
-      output_prop.key.should == prop.key
-
-      output_prop.value.should be_an_instance_of String
-      output_prop.value.should == prop.value
-
-      output_prop.is_updatable.should be_an_instance_of TrueClass
-      output_prop.is_updatable.should == prop.is_updatable
-    end
-
-    it "should_test_payment_method_info_plugin__from_converter" do
-
-      payment_method_info = Killbill::Plugin::PaymentMethodResponseInternal.new("bf5c926e-3d9c-470e-b34b-0719d7b58323", "ca5c926e-3d9c-470e-b34b-0719d7b58312", false, "external_payment_method_id")
-      input = Killbill::Plugin::JPaymentMethodResponseInternal.new(payment_method_info)
-      output = Killbill::Plugin::JConverter.from_payment_method_info_plugin(input)
-
-      output.should be_an_instance_of Killbill::Plugin::PaymentMethodResponseInternal
-
-      output.kb_account_id.should be_an_instance_of String
-      output.kb_account_id.should == payment_method_info.kb_account_id
-
-      output.kb_payment_method_id.should be_an_instance_of String
-      output.kb_payment_method_id.should == payment_method_info.kb_payment_method_id
-
-      output.is_default.should be_an_instance_of FalseClass
-      output.is_default.should == payment_method_info.is_default
-
-      output.external_payment_method_id.should be_an_instance_of String
-      output.external_payment_method_id.should == payment_method_info.external_payment_method_id
-     end
-
      it "should_test_ext_bus_event__from_converter" do
 
        object_type = Java::com.ning.billing.ObjectType::INVOICE
        event_type = Java::com.ning.billing.beatrix.bus.api.ExtBusEventType::INVOICE_CREATION
        uuid = java.util.UUID.random_uuid
 
-       input = Killbill::Plugin::JEvent.new(event_type, object_type, uuid, uuid, uuid)
+       input = Killbill::Plugin::Model::ExtBusEvent.new(event_type, object_type, uuid, uuid, uuid)
        output = Killbill::Plugin::JConverter.from_ext_bus_event(input)
 
-       output.should be_an_instance_of Killbill::Plugin::Event
+       output.should be_an_instance_of Killbill::Plugin::Model::ExtBusEvent
+
+       output.event_type.should == Killbill::Plugin::Model::ExtBusEventType.new(:INVOICE_CREATION)
+
+       output.object_type.should == Killbill::Plugin::Model::ObjectType.new(:INVOICE)
 
-       output.event_type.should be_an_instance_of String
-       output.event_type.should == 'INVOICE_CREATION'
+       output.object_id.should be_an_instance_of Killbill::Plugin::Model::UUID
+       output.object_id.to_s.should == Killbill::Plugin::JConverter.from_uuid(uuid).to_s
 
-       output.object_type.should be_an_instance_of String
-       output.object_type.should == 'INVOICE'
+       output.account_id.should be_an_instance_of Killbill::Plugin::Model::UUID
+       output.account_id.to_s.should == Killbill::Plugin::JConverter.from_uuid(uuid).to_s
+
+       output.tenant_id.should be_an_instance_of Killbill::Plugin::Model::UUID
+       output.tenant_id.to_s.should == Killbill::Plugin::JConverter.from_uuid(uuid).to_s
+
+      end
+      it "should_test_enum_object_type_from_converter" do
 
-       output.object_id.should be_an_instance_of String
-       output.object_id.should == Killbill::Plugin::JConverter.from_uuid(uuid)
+        java_object_type = Java::com.ning.billing.ObjectType::ACCOUNT
 
-       output.account_id.should be_an_instance_of String
-       output.account_id.should == Killbill::Plugin::JConverter.from_uuid(uuid)
+        ruby_object_type = Killbill::Plugin::JConverter.from_object_type(java_object_type)
+        ruby_object_type.should be_an_instance_of Killbill::Plugin::Model::ObjectType
+        ruby_object_type.enum.to_s.should == java_object_type.to_s
 
-       output.tenant_id.should be_an_instance_of String
-       output.tenant_id.should == Killbill::Plugin::JConverter.from_uuid(uuid)
+        java_object_type_back = Killbill::Plugin::JConverter.to_object_type(ruby_object_type)
+        java_object_type_back.should be_an_instance_of Java::com.ning.billing.ObjectType
+        java_object_type_back.to_s.should  == java_object_type.to_s
+        java_object_type_back.to_s.should == "ACCOUNT"
 
       end
 end

data/spec/killbill/jnotification_spec.rb

@@ -5,7 +5,8 @@ require 'killbill/jnotification'
 describe Killbill::Plugin::JNotification do
 
   before(:all) do
-    @jnotification =  Killbill::Plugin::JNotification.new("Killbill::Plugin::NotificationTest")
+    logger = ::Logger.new(STDOUT)
+    @jnotification =  Killbill::Plugin::JNotification.new("Killbill::Plugin::NotificationTest", { "logger" => logger })
   end
 
 

data/spec/killbill/jpayment_spec.rb

@@ -5,7 +5,8 @@ require 'killbill/jpayment'
 describe Killbill::Plugin::JPayment do
 
   before(:all) do
-    @jpayment =  Killbill::Plugin::JPayment.new("Killbill::Plugin::PaymentTest")
+    logger = ::Logger.new(STDOUT)
+    @jpayment =  Killbill::Plugin::JPayment.new("Killbill::Plugin::PaymentTest", { "logger" => logger })
     @kb_account_id = java.util.UUID.fromString("aa5c926e-3d9d-4435-b44b-719d7b583256")
     @kb_payment_id = java.util.UUID.fromString("bf5c926e-3d9c-470e-b34b-719d7b58323a")
     @kb_payment_method_id = java.util.UUID.fromString("bf5c926e-3d9c-470e-b34b-719d7b58323a")
@@ -20,10 +21,10 @@ describe Killbill::Plugin::JPayment do
 
   it "should_test_charge_ok" do
     output = @jpayment.process_payment(@kb_account_id, @kb_payment_id, @kb_payment_method_id, @amount, @currency)
-    output.get_amount.should be_an_instance_of java.math.BigDecimal
-    output.get_amount.to_s.should == "50.00";
-    output.get_status.should be_an_instance_of Java::com.ning.billing.payment.plugin.api.PaymentInfoPlugin::PaymentPluginStatus
-    output.get_status.to_s.should == "PROCESSED"
+    output.amount.should be_an_instance_of java.math.BigDecimal
+    output.amount.to_s.should == "50.00";
+    output.status.should be_an_instance_of Java::com.ning.billing.payment.plugin.api.PaymentPluginStatus
+    output.status.to_s.should == "PROCESSED"
   end
 
   it "should_test_charge_exception" do
@@ -33,10 +34,10 @@ describe Killbill::Plugin::JPayment do
 
   it "should_test_get_payment_info_ok" do
     output = @jpayment.get_payment_info(@kb_account_id, @kb_payment_method_id)
-    output.get_amount.should be_an_instance_of java.math.BigDecimal
-    output.get_amount.to_s.should == "0.00";
-    output.get_status.should be_an_instance_of Java::com.ning.billing.payment.plugin.api.PaymentInfoPlugin::PaymentPluginStatus
-    output.get_status.to_s.should == "PROCESSED"
+    output.amount.should be_an_instance_of java.math.BigDecimal
+    output.amount.to_s.should == "0.00";
+    output.status.should be_an_instance_of Java::com.ning.billing.payment.plugin.api.PaymentPluginStatus
+    output.status.to_s.should == "PROCESSED"
   end
 
   it "should_test_get_payment_info_exception" do
@@ -46,10 +47,10 @@ describe Killbill::Plugin::JPayment do
 
   it "should_test_refund_ok" do
     output = @jpayment.process_refund(@kb_account_id, @kb_payment_method_id, @amount, @currency)
-    output.get_amount.should be_an_instance_of java.math.BigDecimal
-    output.get_amount.to_s.should == "50.00";
-    output.get_status.should be_an_instance_of Java::com.ning.billing.payment.plugin.api.RefundInfoPlugin::RefundPluginStatus
-    output.get_status.to_s.should == "PROCESSED"
+    output.amount.should be_an_instance_of java.math.BigDecimal
+    output.amount.to_s.should == "50.00";
+    output.status.should be_an_instance_of Java::com.ning.billing.payment.plugin.api.RefundPluginStatus
+    output.status.to_s.should == "PROCESSED"
   end
 
   it "should_test_refund_exception" do
@@ -77,8 +78,8 @@ describe Killbill::Plugin::JPayment do
 
   it "should_test_get_payment_method_detail_ok" do
     output = @jpayment.get_payment_method_detail(@kb_account_id, @kb_payment_method_id)
-    output.get_external_payment_method_id.should be_an_instance_of java.lang.String
-    output.get_external_payment_method_id.should == "foo"
+    output.external_payment_method_id.should be_an_instance_of java.lang.String
+    output.external_payment_method_id.should == "foo"
   end
 
   it "should_test_get_payment_method_detail_exception" do
@@ -102,7 +103,7 @@ describe Killbill::Plugin::JPayment do
     output.size.should == 1
 
     current_payment_method = output.get(0)
-    current_payment_method.get_account_id.to_s.should == @kb_account_id.to_s
+    current_payment_method.account_id.to_s.should == @kb_account_id.to_s
   end
 
   it "should_get_payment_methods_exception" do

data/spec/killbill/killbill_integration_spec.rb

@@ -10,7 +10,7 @@ describe Killbill::Plugin do
   end
 
   it 'should be able to access Killbill mock APIs' do
-    @account_user_api.createAccount(UUID.randomUUID,
+    @account_user_api.createAccountFromParams(UUID.randomUUID,
                                     'externalKey',
                                     'email',
                                     'name',

data/spec/killbill/killbillapi_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+require 'killbill/jkillbill_api'
+require 'killbill/killbill_api'
+
+require 'killbill/gen/account_data'
+require 'killbill/gen/currency'
+require 'killbill/gen/date_time_zone'
+
+
+
+describe Killbill::Plugin do
+
+  before(:each) do
+    @account_user_api_mock = MockAccountUserApi.new
+    @japi_proxy = Killbill::Plugin::JKillbillApi.new("foo", {:account_user_api => @account_user_api_mock})
+    @kb_apis = Killbill::Plugin::KillbillApi.new(@japi_proxy)
+    @account = Killbill::Plugin::Model::AccountData.new("external_key", "name", 3, "email", 1, Killbill::Plugin::Model::Currency.new(:USD), nil, Killbill::Plugin::Model::DateTimeZone.new(:UTC), "locale", "address1", nil,
+"company_name", "city", "state_or_province", "postal_code", "country", "phone", true, false)
+  end
+
+  it 'should test create/get_account_by_id' do
+
+    account_created = @kb_apis.create_account(@account)
+    account_created.should be_an_instance_of Killbill::Plugin::Model::Account
+
+    account_fetched = @kb_apis.get_account_by_id(account_created.id)
+    account_fetched.should be_an_instance_of Killbill::Plugin::Model::Account
+    account_fetched.id.should be_an_instance_of Killbill::Plugin::Model::UUID
+    account_fetched.id.to_s.should == account_created.id.to_s
+    account_fetched.external_key.should == "external_key"
+    account_fetched.name.should == "name"
+    account_fetched.first_name_length.should == 3
+    account_fetched.email.should == "email"
+    account_fetched.bill_cycle_day_local.should == 1
+    account_fetched.currency.should == Killbill::Plugin::Model::Currency.new(:USD)
+    account_fetched.locale.should == "locale"
+    account_fetched.address1.should == "address1"
+    account_fetched.address2.should == nil
+    account_fetched.time_zone.should == Killbill::Plugin::Model::DateTimeZone.new(:UTC)
+    account_fetched.company_name.should == "company_name"
+    account_fetched.city.should == "city"
+    account_fetched.state_or_province.should == "state_or_province"
+    account_fetched.postal_code.should == "postal_code"
+    account_fetched.country.should == "country"
+    account_fetched.phone.should == "phone"
+  end
+
+end

data/spec/killbill/payment_test.rb

@@ -12,7 +12,7 @@ module Killbill
         if @raise_exception
           raise StandardError.new("Test exception")
         else
-          PaymentResponse.new(amount_in_cents, DateTime.now, DateTime.now, PaymentStatus::SUCCESS, "gateway_error", "gateway_error_code")
+          Killbill::Plugin::Model::PaymentInfoPlugin.new(amount_in_cents, DateTime.now, DateTime.now, Killbill::Plugin::Model::PaymentPluginStatus.new(:PROCESSED), "gateway_error", "gateway_error_code", nil, nil)
         end
       end
 
@@ -20,7 +20,7 @@ module Killbill
         if @raise_exception
           raise StandardError.new("Test exception")
         else
-          PaymentResponse.new(0, DateTime.now, DateTime.now, PaymentStatus::SUCCESS, "gateway_error", "gateway_error_code")
+          Killbill::Plugin::Model::PaymentInfoPlugin.new(0, DateTime.now, DateTime.now, Killbill::Plugin::Model::PaymentPluginStatus.new(:PROCESSED), "gateway_error", "gateway_error_code", nil, nil)
         end
       end
 
@@ -28,7 +28,7 @@ module Killbill
         if @raise_exception
           raise StandardError.new("Test exception")
         else
-          RefundResponse.new(amount_in_cents, DateTime.now, DateTime.now, PaymentStatus::SUCCESS, "gateway_error", "gateway_error_code")
+          Killbill::Plugin::Model::RefundInfoPlugin.new(5000, DateTime.now, DateTime.now, Killbill::Plugin::Model::RefundPluginStatus.new(:PROCESSED), "gateway_error", "gateway_error_code", nil)
         end
       end
 
@@ -48,7 +48,7 @@ module Killbill
         if @raise_exception
           raise StandardError.new("Test exception")
         else
-          PaymentMethodResponse.new("foo", true, [])
+          Killbill::Plugin::Model::PaymentMethodPlugin.new("foo", true, [], nil, "type", "cc_name", "cc_type", "cc_expiration_month", "cc_expiration_year", "cc_last4", "address1", "address2", "city", "state", "zip", "country")
         end
       end
 
@@ -62,7 +62,7 @@ module Killbill
         if @raise_exception
           raise StandardError.new("Test exception")
         else
-          [PaymentMethodResponseInternal.new(kb_account_id, kb_account_id, true, "external_payment_method_id")]
+          [Killbill::Plugin::Model::PaymentMethodInfoPlugin.new(kb_account_id, kb_account_id, true, "external_payment_method_id")]
         end
       end
 

data/spec/killbill/rack_handler_spec.rb

@@ -1,12 +1,11 @@
 require 'spec_helper'
-require 'logger'
 
 describe Killbill::Plugin::RackHandler do
   it 'should be able to register Sinatra apps' do
     rack = Killbill::Plugin::RackHandler.instance
     rack.configured?.should be_false
 
-    rack.configure(Logger.new(STDOUT), File.expand_path('../config_test.ru', __FILE__))
+    rack.configure(Killbill::Plugin::KillbillLogger.new(::Logger.new(STDOUT)), File.expand_path('../config_test.ru', __FILE__))
     rack.configured?.should be_true
 
     status, headers, body = rack.rack_service('/ping')

data/spec/spec_helper.rb

@@ -1,9 +1,12 @@
+
+
 require 'java'
 
 require 'bundler'
 require 'logger'
 
 require 'killbill'
+require 'killbill/killbill_logger'
 # JRuby specific, not required by default
 require 'killbill/http_servlet'
 

data/tools/java2ruby.rb

@@ -0,0 +1,440 @@
+require 'rubygems'
+require 'optparse'
+
+
+# Relative path from Killbill repo
+API_DIR_SRC="api/src/main/java"
+
+# Interfaces to consider
+INTERFACES = ["Account",
+              "AccountData",
+              "AccountEmail",
+              "BlockingState",
+              "ExtBusEvent",
+              "ExtBusEventType",
+              "ObjectType",
+              "Subscription",
+              "SubscriptionState",
+              "SubscriptionSourceType",
+              "SubscriptionBundle",
+              "Invoice",
+              "InvoiceItem",
+              "InvoicePayment",
+              "InvoicePaymentType",
+              "Payment",
+              "PaymentAttempt",
+              "Refund",
+              "AuditLog",
+              "CallContext",
+              "CallOrigin",
+              "UserType",
+              "TenantContext",
+              "CustomField",
+              "Tag",
+              "TagDefinition",
+              "Currency",
+              "PaymentInfoPlugin",
+              "PaymentPluginStatus",
+              "RefundInfoPlugin",
+              "RefundPluginStatus",
+              "PaymentMethodKVInfo",
+              "PaymentMethodPlugin",
+              "PaymentMethodInfoPlugin"]
+
+
+class String
+   def snake_case
+     return downcase if match(/\A[A-Z]+\z/)
+     gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+     gsub(/([a-z])([A-Z])/, '\1_\2').
+     downcase
+   end
+end
+
+class Pojo
+
+  attr_accessor :name, :package,  :fields
+
+  def initialize(dummy=nil)
+     @name = nil
+     @package = nil
+     @fields = []
+  end
+end
+
+=begin
+  class ObjectType
+
+    @@admissible_values  = [:ACCOUNT, :ACCOUNT_EMAIL]
+    attr_reader :enum
+
+    def initialize(value)
+      @enum = value
+    end
+
+  def self.is_admissible_value(value)
+    @@admissible_values.include?(value)
+  end
+
+  def self.admissible_values
+     @@admissible_values
+   end
+=end
+
+class PojoEnum < Pojo
+
+  def initialize
+    super
+  end
+
+  def generate(out)
+    out.write("\n")
+    out.write("\#\n")
+    out.write("\# Ruby classes automatically generated from java classes-- don't edit\n")
+    out.write("\#\n")
+    out.write("module Killbill\n")
+    out.write("  module Plugin\n")
+    out.write("    module Model\n")
+    out.write("\n")
+    out.write("      class #{name}\n")
+    out.write("\n")
+    out.write("        @@admissible_values  = #{@fields.collect {|e| e.to_sym }}\n")
+    out.write("        attr_reader :enum\n")
+    out.write("\n")
+    out.write("        def initialize(value)\n")
+    out.write("          raise ArgumentError.new(\"Enum #{name} does not have such value : \#{value}\") if ! #{name}.is_admissible_value?(value)\n")
+    out.write("          @enum = value\n")
+    out.write("        end\n")
+    out.write("\n")
+    out.write("        def ==(other)\n")
+    out.write("          return false if other.nil?\n")
+    out.write("          self.enum == other.enum\n")
+    out.write("        end\n")
+    out.write("\n")
+    out.write("        def self.is_admissible_value?(value)\n")
+    out.write("          @@admissible_values.include?(value)\n")
+    out.write("        end\n")
+    out.write("\n")
+    out.write("        def self.admissible_values \n")
+    out.write("          @@admissible_values\n")
+    out.write("        end\n")
+    out.write("      end\n")
+    out.write("    end\n")
+    out.write("  end\n")
+    out.write("end\n")
+    out.flush
+  end
+
+  def export(output_dir, parents_pojo)
+    @fields.uniq!
+    File.open("#{output_dir}/#{name.snake_case}.rb", "w+") do |f|
+      generate(f)
+    end
+  end
+
+
+
+end
+
+class PojoIfceOrClass < Pojo
+
+  attr_accessor :interface, :parents
+
+  def initialize(is_interface)
+    super
+    @interface = is_interface
+    @parents = []
+  end
+
+  def generate(out)
+    out.write("\n")
+    out.write("\#\n")
+    out.write("\# Ruby classes automatically generated from java classes-- don't edit\n")
+    out.write("\#\n")
+    out.write("module Killbill\n")
+    out.write("  module Plugin\n")
+    out.write("    module Model\n")
+    out.write("\n")
+    out.write("      class #{name}\n")
+    out.write("\n")
+    if @interface
+      out.write("        include #{@package}.#{@name}\n")
+      out.write("\n")
+    end
+    out.write("        attr_reader #{fields.collect { |i| ":#{i}"}.join(", ")}\n")
+    out.write("\n")
+    out.write("        def initialize(#{@fields.join(", ")})\n")
+    fields.each do |f|
+      out.write("          @#{f} = #{f}\n")
+    end
+    out.write("        end\n")
+    out.write("      end\n")
+    out.write("    end\n")
+    out.write("  end\n")
+    out.write("end\n")
+    out.flush
+  end
+
+  def export(output_dir, parents_pojo)
+    parents.each do |p|
+      if ! parents_pojo[p].nil?
+        (@fields.unshift(parents_pojo[p].fields)).flatten!
+      end
+    end
+    @fields.uniq!
+    File.open("#{output_dir}/#{name.snake_case}.rb", "w+") do |f|
+      generate(f)
+    end
+  end
+
+  def to_s
+    "#{@name} : #{@fields.join(",")}"
+  end
+
+
+end
+
+
+class Visitor
+
+  attr_reader :pojo
+
+  def initialize
+    @pojo = nil
+  end
+
+  def create_interface(name, package)
+    @pojo = PojoIfceOrClass.new(true)
+    @pojo.name = name
+    @pojo.package = package
+  end
+
+  def create_class(name, package)
+    @pojo = PojoIfceOrClass.new(false)
+    @pojo.name = name
+    @pojo.package = package
+  end
+
+  def create_enum(name, package)
+    @pojo = PojoEnum.new
+    @pojo.name = name
+    @pojo.package = package
+  end
+
+  def add_parents(parents)
+    (@pojo.parents << parents).flatten!
+  end
+
+  def add_getter(getter)
+    @pojo.fields << getter.snake_case
+  end
+
+  def add_enum_field(enum_field)
+    @pojo.fields << enum_field
+  end
+end
+
+class Generator
+
+  attr_reader :output_dir, :finder, :files
+
+  def initialize(output_dir, interfaces, finder)
+    @output_dir = output_dir
+    @finder = finder
+    @files = finder.search(interfaces)
+  end
+
+  def generate_all
+
+    pojos = []
+    @files.each do |i|
+      generate_file(i) do |pojo|
+        pojos << pojo
+      end
+    end
+
+    parent_pojos = {}
+
+    parent_ifces = []
+    pojos.each do |pojo|
+      if pojo.is_a? PojoIfceOrClass
+        (parent_ifces << pojo.parents).flatten!
+      end
+    end
+    parent_ifces.uniq!
+
+    puts "UNIQ PARENTS = #{parent_ifces.to_s}"
+
+    parent_files = finder.search(parent_ifces)
+    puts "PARENT FILES  = #{parent_files}"
+    parent_files.each do |i|
+      puts "Starting processing parent file #{i}"
+      generate_file(i) do |pojo|
+        parent_pojos[pojo.name] = pojo
+      end
+    end
+
+    pojos.each do |pojo|
+      puts "Starting processing file #{pojo.name}"
+
+      pojo.export(@output_dir, parent_pojos)
+
+      File.open("#{output_dir}/require_gen.rb", "w+") do |f|
+        pojos.each do |pojo|
+          f.write("require \'killbill/gen/#{pojo.name.snake_case}\'\n")
+        end
+      end
+      puts "Completing processing file #{pojo.name}"
+    end
+  end
+
+  private
+
+
+  def generate_file(file)
+    visitor = Visitor.new
+    File.open(file, "r") do |f|
+
+      is_enum = false
+      is_interface = false
+      is_class = false
+      package = nil
+      while (line = f.gets)
+
+        # Package
+        re = /\s*package\s+((?:\w|\.)+)\s*;/
+        if re.match(line)
+          package = $1
+        end
+
+        # Interface
+        re = /public\s+(interface|class)\s+(\w+)\s+(extends(?:\w|,|\s|<|>)+){0,1}\s*{\s*/
+        if re.match(line)
+          is_interface = ($1 == "interface")
+          is_class = ($1 == "class")
+          name = $2
+          visitor.create_interface(name, package) if is_interface
+          visitor.create_class(name, package) if is_class
+          if ! $3.nil?
+            re = /\s*extends\s+(.*)/
+            extends_ifces = $3
+            if re.match(extends_ifces)
+              # extract each parent and remove trailing, leading space
+              parents = $1.split(",").collect { |e| e.strip}
+              # remove generics
+              re = /(\w+)(?:<\w+>){0,1}/
+              parents.collect! { |e| re.match(e); $1 }
+              visitor.add_parents(parents)
+            end
+          end
+        end
+
+        # Enum
+        re = /public\s+enum\s+(\w+)\s+/
+        if re.match(line)
+          enum_name = $1
+          visitor.create_enum(enum_name, package)
+          is_enum = true
+          is_enum_complete = false
+        end
+
+        # Non static getters for interfaces
+        re = /(?:public){0,1}\s+(?:static\s+(?:\w|<|>)+)\s+(?:get|is).*/
+        if (is_interface || is_class) && !re.match(line)
+          re = /(?:public){0,1}\s+(?:(?:\w|<|>)+)\s+get(\w+)()\s*/
+          if re.match(line)
+            visitor.add_getter($1)
+          end
+          re = /(?:public){0,1}\s+(?:(?:\w|<|>)+)\s+(is\w+)()\s*/
+          if re.match(line)
+            visitor.add_getter($1)
+          end
+        end
+
+        # Enum fields
+        re = /\s+((?:\w|_)+)(?:\((?:\w|\s|\")+\)){0,1}\s*(,|;){1}/
+        if !is_enum_complete && is_enum && re.match(line)
+          visitor.add_enum_field($1.strip)
+          if $2 == ';'
+            is_enum_complete = true
+          end
+        end
+      end
+    end
+    yield(visitor.pojo)
+  end
+end
+
+
+class Finder
+
+  attr_reader :interfaces, :src_dir
+
+  def initialize(src_dir)
+    @interfaces = interfaces
+    @src_dir = src_dir
+  end
+
+  def search(interfaces)
+    res = []
+    if !interfaces.nil? && interfaces.size > 0
+      Dir.chdir(@src_dir)
+      Dir.glob("**/*") do |e|
+        if File.file?(e)
+          basename = File.basename(e, ".java")
+          if interfaces.include? basename
+            res << e
+          end
+        end
+      end
+    end
+    res
+  end
+end
+
+
+class CommandParser
+
+  attr_reader :options, :args, :interfaces, :src_relative_path
+
+  def initialize(args, interfaces, src_relative_path)
+    @options = {}
+    @args = args
+    @interfaces = interfaces
+    @src_relative_path = src_relative_path
+  end
+
+
+  def run
+    parse
+    puts "Generating ruby classes under: #{@options[:output]}"
+    finder = Finder.new("#{@options[:src]}/#{@src_relative_path}")
+    gen = Generator.new(@options[:output], @interfaces, finder)
+    gen.generate_all
+  end
+
+  private
+
+  def parse()
+    optparse = OptionParser.new do |opts|
+      opts.banner = "Usage: java2ruby.rb [options]"
+
+      opts.separator ""
+
+      opts.on("-o", "--output OUTPUT",
+      "Output directory") do |o|
+        @options[:output] = o
+      end
+
+      opts.on("-s", "--src SRC",
+      "Killbill source directory") do |s|
+        @options[:src] = s
+      end
+    end
+    optparse.parse!(@args)
+  end
+
+end
+
+parser = CommandParser.new(ARGV, INTERFACES, API_DIR_SRC)
+parser.run