squash_java 1.0.0

data/LICENSE.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,98 @@
+Squash Java Deobfuscation Library
+=================================
+
+This gem serves three purposes:
+
+* to upload yGuard obfuscation data to Squash,
+* to map class names to their file paths, and upload that data to Squash, and
+* to notify Squash of new releases of Java software (internally or externally).
+
+This gem installs a `deobfuscate` binary that converts a renamelog.xml file into
+a format usable for Squash, locates the files in which classes are defined, and
+then uploads that data to the Squash host. It also installs a `squash_release`
+binary that notifies Squash of the release.
+
+Documentation
+-------------
+
+Comprehensive documentation is written in YARD- and Markdown-formatted comments
+throughout the source. To view this documentation as an HTML site, run
+`rake doc`.
+
+For an overview of the various components of Squash, see the website
+documentation at https://github.com/SquareSquash/web.
+
+Compatibility
+-------------
+
+This library is compatible with Ruby 1.8.6 and later, including Ruby Enterprise
+Edition.
+
+Requirements
+------------
+
+This gem requires the `json` gem (http://rubygems.org/gems/json). You can use
+any JSON gem that conforms to the typical standard
+(`require 'json'; object.to_json`).
+
+Usage
+-----
+
+### Uploading Obfuscation and Class Path Data
+
+This gem installs a command-line binary named `deobfuscate`. It is called in the
+following format:
+
+````
+deobfuscate [options] <API key> <environment> <build number> <renamelog file>
+````
+
+Example: `deobfuscate --no-ssl-verification a9232f94-6c2d-45ae-8f9e-9add5bd7ff35 production 103 /path/to/renamelog.xml`
+
+This binary is intended to be used as part of your release process. It will
+first parse the renamelog file and generate an internal representation of your
+program's namespace, along with all obfuscated aliases. Then it will attempt to
+map class names to the files in which the classes are defined. In order for this
+to work, your classes should be organized in folder structures according to
+their package names. For example, the source of the class `com.foo.bar.Baz`
+should be found in a "com/foo/bar/Baz.java" file path somewhere in your project.
+
+By default this program assumes it's being run from the project root, but you
+can also specify the root with the `--project-dir` switch. For documentation on
+`deobfuscate`'s command-line options, run `deobfuscate --help.`
+
+### Release Notification
+
+This gem installs a command-line binary named `squash_release`. It is called in
+the following format:
+
+````
+squash_release [options] <API key> <environment> <build number>
+````
+
+Example: `squash_release a9232f94-6c2d-45ae-8f9e-9add5bd7ff35 production 103 `
+
+This binary is intended to be used as part of your release process, similar to
+`deobfuscate` (see above). Like `deobfuscate`, sensible defaults are provided
+for all command line switches.
+
+For documentation on `squash_release`'s command-line options, run
+`squash_release --help`.
+
+Data Transmission
+-----------------
+
+Deobfuscation and release data is transmitted to Squash using JSON-over-HTTPS. A
+default API endpoint is pre-configured, though you can always set your own (see
+`deobfuscate --help` or `squash_release --help`).
+
+By default, `Net::HTTP` is used to transmit errors to the API server. If you
+would prefer to use your own HTTP library, see the `squash_uploader` gem.
+
+Use as a Library
+----------------
+
+In addition to using the rename map with Squash, you can also use the gem as
+a library, to perform deobfuscation for your own purposes (even unrelated to
+Squash). See the {Squash::Java::Namespace} class documentation for more
+information.

data/bin/deobfuscate

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+# Copyright 2012 Square Inc.
+#
+#    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
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+require 'optparse'
+require 'base64'
+require 'zlib'
+require 'yaml'
+
+require 'rubygems'
+require 'squash/uploader'
+require 'squash/java'
+
+def git_revision(dir)
+  head = File.read(File.join(dir, '.git', 'HEAD')).chomp
+  if head =~ /^ref: (.+)$/
+    File.read(File.join(dir, '.git', $1)).chomp
+  else
+    raise "Couldn't determine current revision from #{head.inspect}"
+  end
+end
+
+project_dir = Dir.getwd
+revision    = nil
+options     = {}
+
+parser = OptionParser.new do |parser|
+  parser.banner = "Usage: deobfuscate [options] YOUR_SQUASH_HOST YOUR_API_KEY ENVIRONMENT_NAME BUILD_NUMBER /path/to/renamelog_or_mapping"
+  parser.on('-o', '--open-timeout N', Integer, "HTTP connection open timeout") { |ot| options[:open_timeout] = ot }
+  parser.on('-r', '--read-timeout N', Integer, "HTTP connection data received timeout") { |rt| options[:read_timeout] = rt }
+  parser.on('-k', '--[no-]skip-verification', "Do not perform SSL peer verification") { |sv| options[:skip_verification] = sv }
+
+  parser.on('-p', '--project-dir F', "Specify a custom project directory (default current directory)") { |pd| project_dir = pd }
+  parser.on('-r', '--revision R', "Specify a code revision that was deployed (default current revision)") { |r| revision = r }
+
+  parser.on('-h', '--help', "Show this message") { puts parser; exit }
+  parser.on('--version', "Display version number of this program") { puts "1.0.0"; exit }
+end
+parser.parse!(ARGV)
+
+if ARGV.size != 5
+  puts parser
+  exit 1
+end
+
+host        = ARGV.shift
+api_key     = ARGV.shift
+environment = ARGV.shift
+build       = ARGV.shift
+file        = ARGV.shift
+revision    = revision || git_revision(project_dir)
+
+namespace = Squash::Java::RenameLog.new(file).parse
+namespace.find_files project_dir
+
+Squash::Uploader.new(host, options).transmit '/api/1.0/deobfuscation.json',
+                                             {
+                                                 'api_key'     => api_key,
+                                                 'environment' => environment,
+                                                 'build'       => build,
+                                                 'namespace'   => Base64.encode64(Zlib::Deflate.deflate(namespace.to_yaml))
+                                             }

data/bin/squash_release

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+
+# Copyright 2012 Square Inc.
+#
+#    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
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+require 'optparse'
+require 'rubygems'
+require 'squash/uploader'
+
+def git_revision(dir)
+  head = File.read(File.join(dir, '.git', 'HEAD')).chomp
+  if head =~ /^ref: (.+)$/
+    File.read(File.join(dir, '.git', $1)).chomp
+  else
+    raise "Couldn't determine current revision from #{head.inspect}"
+  end
+end
+
+project_dir = Dir.getwd
+revision    = nil
+options     = {}
+
+parser = OptionParser.new do |parser|
+  parser.banner = "Usage: squash_release [options] YOUR_SQUASH_HOST YOUR_API_KEY ENVIRONMENT BUILD_NUMBER"
+  parser.on('-o', '--open-timeout N', Integer, "HTTP connection open timeout") { |ot| options[:open_timeout] = ot }
+  parser.on('-r', '--read-timeout N', Integer, "HTTP connection data received timeout") { |rt| options[:read_timeout] = rt }
+  parser.on('-k', '--[no-]skip-verification', "Do not perform SSL peer verification") { |sv| options[:skip_verification] = sv }
+
+  parser.on('-p', '--project-dir F', "Specify a custom project directory (default current directory)") { |pd| project_dir = pd }
+  parser.on('-r', '--revision R', "Specify a code revision that was deployed (default current revision)") { |r| revision = r }
+
+  parser.on('-h', '--help', "Show this message") { puts parser; exit }
+  parser.on('--version', "Display version number of this program") { puts "1.0.0"; exit }
+end
+parser.parse!(ARGV)
+
+if ARGV.size != 4
+  puts parser
+  exit 1
+end
+
+host        = ARGV.shift
+api_key     = ARGV.shift
+environment = ARGV.shift
+build       = ARGV.shift
+revision    = revision || git_revision(project_dir)
+
+Squash::Uploader.new(host, options).transmit '/api/1.0/deploy.json',
+                                             {
+                                                 'project'     => {'api_key' => api_key},
+                                                 'environment' => {'name' => environment},
+                                                 'deploy'      => {
+                                                     'deployed_at' => Time.now,
+                                                     'revision'    => revision,
+                                                     'build'       => build
+                                                 }
+                                             }

data/lib/squash/java/namespace.rb

@@ -0,0 +1,553 @@
+# Copyright 2012 Square Inc.
+#
+#    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
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+require 'set'
+require 'find'
+
+
+# A Ruby representation of the packages, classes, methods, and fields of a
+# Java project, with their full and obfuscated names. The {RenameLog} class
+# loads a Namespace from a yGuard or ProGuard rename log file.
+#
+# **Note:** Some of the finder methods of this class and its enclosed classes
+# are find-or-create-type methods. Read the method documentation for each
+# method carefully.
+#
+# **Another note:** A distinction is made between _full_ and _partial_ names
+# (e.g., "MyClass" vs. "com.mycompany.MyClass"), and _cleartext_ and
+# _obfuscated_ names (e.g., "com.mycompany.MyClass" vs. "com.A.B"). Note that
+# there are four possible combinations of these states. Method docs will state
+# what naming format is expected for each parameter.
+
+class Squash::Java::Namespace
+  # @private
+  METHOD_REGEX = /^([a-z0-9_.$\[\]]+) ([a-z0-9_$]+)\(([a-z$0-9_.\[\] ,]*)\)/i
+
+  # Creates a new empty Namespace.
+
+  def initialize
+    @package_roots = Set.new
+  end
+
+  # @overload find_files(root)
+  #   Attempts to locate the paths to the {Squash::Java::Class Classes} defined
+  #   in this Namespace. Classes must be defined in files named after the class,
+  #   organized into folders structured after the classes' packages. For
+  #   example, the source of the `com.foo.bar.Baz` class should be defined in a
+  #   file located at "com/foo/bar/Baz.java", somewhere inside your project
+  #   root. This is a "best guess" attempt and will not work every time.
+  #
+  #   Once this method is complete, any Class objects under this namespace that
+  #   were successfully matched will have their {Squash::Java::Class#path path}
+  #   attributes set.
+  #
+  #   @param [String] root The project root. All source directories must be
+  #     under this root.
+
+  def find_files(root, package_or_class=nil)
+    case package_or_class
+      when nil
+        root.sub! /\/$/, ''
+        @package_roots.each { |pkg| find_files root, pkg }
+      when Squash::Java::Package
+        package_or_class.classes.each { |cl| find_files root, cl }
+        package_or_class.children.each { |pkg| find_files root, pkg }
+      when Squash::Java::Class
+        class_subpath = package_or_class.subpath
+        Find.find(root) do |project_path|
+          if project_path[0, root.length + 2] == root + '/.'
+            Find.prune
+            next
+          end
+          if project_path[-class_subpath.length, class_subpath.length] == class_subpath
+            package_or_class.path = project_path.sub(/^#{Regexp.escape root}\//, '')
+          end
+        end
+    end
+  end
+
+  # Returns the path to a {Squash::Java::Class Class}'s source .java file,
+  # relative to the project root, if a) the class exists in the namespace, and
+  # b) the class has a known path.
+  #
+  # @param [String] klass The full class name (parts of which can be
+  #   obfuscated), e.g., "com.foo.A.Baz".
+  # @return [String, nil] The path to the class's source file, if known.
+  # @see #find_files
+
+  def path_for_class(klass)
+    cl = obfuscated_class(klass)
+    cl ? cl.path : nil
+  end
+
+  # Associates a full package name with an obfuscated name.
+  #
+  # @param [String] name The full package name (e.g., "com.foo.bar").
+  # @param [String] obfuscation The obfuscated name for just the last segment of
+  #   the full name (e.g., "A").
+  # @return [Squash::Java::Package] The newly created package object.
+
+  def add_package_alias(name, obfuscation)
+    pkg             = package(name)
+    pkg.obfuscation = obfuscation
+    return pkg
+  end
+
+  # Associates a full class name with an obfuscated name.
+  #
+  # @param [String] name The full class name (e.g., "com.foo.bar.Baz").
+  # @param [String] obfuscation The obfuscated name for just the last segment of
+  #   the full name (e.g., "A").
+  # @return [Squash::Java::Class] The newly created class object.
+
+  def add_class_alias(name, obfuscation)
+    cl             = klass(name)
+    cl.obfuscation = obfuscation
+    return cl
+  end
+
+  # Associates a method name with an obfuscated alias.
+  #
+  # @param [String, Squash::Java::Class] class_or_name A full class name (e.g.,
+  #   "com.foo.bar.Baz"), or a class object.
+  # @param [String] method_name A method name, with return value and argument
+  #  types (e.g., "com.foo.Type1 methodName(com.foo.Type2, int[])").
+  # @return [Squash::Java::Method] The newly created method object.
+
+  def add_method_alias(class_or_name, method_name, obfuscation)
+    cl               = (class_or_name.kind_of?(Squash::Java::Class) ? class_or_name : klass(class_or_name))
+    meth             = method(cl, method_name)
+    meth.obfuscation = obfuscation
+    return meth
+  end
+
+  # **Finds or creates** a package by its full name.
+  #
+  # @param [String] identifier A full package name (e.g., "com.foo.bar").
+  # @return [Squash::Java::Package] The package with that name.
+
+  def package(identifier)
+    parts     = identifier.split('.')
+    root_name = parts.shift
+    root      = @package_roots.detect { |pkg| pkg.name == root_name } || begin
+      pkg = Squash::Java::Package.new(root_name)
+      @package_roots << pkg
+      pkg
+    end
+    if parts.empty?
+      root
+    else
+      root.find_or_create(parts.join('.'))
+    end
+  end
+
+  alias klass package
+
+  # **Finds** a package by its obfuscated (or partially obfuscated) full name.
+  # (Technically it also works as a **find-only** variant of {#package} since
+  # all, some, or none of the name need be obfuscated.)
+  #
+  # @param [String] identifier An obfuscated full package name (e.g.,
+  #   "com.foo.A").
+  # @return [Squash::Java::Package, nil] The package with that obfuscated name.
+
+  def obfuscated_package(identifier)
+    parts     = identifier.split('.')
+    root_name = parts.shift
+    root      = @package_roots.detect { |pkg| pkg.name == root_name }
+    if parts.empty?
+      root
+    else
+      root ? root.find_obfuscated(parts.join('.')) : nil
+    end
+  end
+
+  # **Finds** a class by its obfuscated (or partially obfuscated) full name.
+  # (Technically it also works as a **find-only** variant of {#klass} since all
+  # some, or none of the name need be obfuscated.)
+  #
+  # @param [String] identifier An obfuscated full class name (e.g.,
+  #   "com.foo.A.B").
+  # @return [Squash::Java::Class, nil] The class with that obfuscated name.
+
+  def obfuscated_class(identifier)
+    parts      = identifier.split('.')
+    class_name = parts.pop
+    pkg        = obfuscated_package(parts.join('.'))
+    return nil unless pkg
+
+    pkg.classes.detect { |cl| cl.obfuscation == class_name || cl.name == class_name }
+  end
+
+  # **Finds or creates** a primitive or class type by its name.
+  #
+  # @param [String] name The type name (e.g., "int" or "FooClass").
+  # @return [Squash::Java::Type] The type object.
+
+  def type(name)
+    Squash::Java::PRIMITIVES.detect { |prim| prim.name == name } || klass(name)
+  end
+
+  # **Finds** a class or primitive type by its obfuscated name. Primitives are
+  # never obfuscated.
+  #
+  # @param [String] name The obfuscated full class name (e.g.,
+  #   "com.squareup.A.B") or full primitive name
+  # @return [Squash::Java::Type, nil] The type of that name, if found.
+
+  def obfuscated_type(name)
+    Squash::Java::PRIMITIVES.detect { |prim| prim.name == name } || obfuscated_class(name)
+  end
+
+  # **Finds or creates** a method by its name and parent class. Polymorphism is
+  # supported: Two methods can share the same name so long as their argument
+  # count or types are different.
+  #
+  # @param [Squash::Java::Class] klass The class containing the method.
+  # @param [String] name The method name, with return type and arguments as
+  #   full, unobfuscated types (e.g., "com.foo.Bar myMethod(com.foo.Baz, int[])".
+  # @return [Squash::Java::Method] The corresponding method.
+
+  def method(klass, name)
+    matches = name.match(METHOD_REGEX) or raise "Invalid method name #{name.inspect}"
+    return_type = type(matches[1])
+    method_name = matches[2]
+    args        = matches[3].split(/,\s*/).map { |arg| argument(arg) }
+    args = [] if matches[3].empty?
+
+    klass.java_methods.detect { |meth| meth.name == method_name && meth.arguments == args } ||
+        Squash::Java::Method.new(klass, method_name, return_type, *args)
+  end
+
+  # **Finds** a method by its obfuscated name and parent class. Polymorphism is
+  # supported: Two methods can share the same name so long as their argument
+  # count or types are different.
+  #
+  # @param [Squash::Java::Class] klass The class containing the method.
+  # @param [String] name The obfuscated method name, with return type and
+  #   arguments as full, obfuscated types (e.g., "com.foo.A myMethod(com.foo.B, int[])".
+  # @return [Squash::Java::Method, nil] The corresponding method.
+
+  def obfuscated_method(klass, name)
+    matches = name.match(METHOD_REGEX) or raise "Invalid method name #{name.inspect}"
+    return_type = obfuscated_type(matches[1])
+    method_name = matches[2]
+    args        = matches[3].split(/,\s*/).map { |arg| obfuscated_argument(arg) }
+    args = [] if matches[3].empty?
+    klass.java_methods.detect { |m| m.obfuscation == method_name && m.arguments == args }
+  end
+
+  # Creates a new Argument for a given type descriptor. This can be a
+  # primitive (e.g., "float") or a full class name (e.g., "com.foo.Bar"), and
+  # can be a scalar or an array (e.g., "float[]" or "com.foo.Bar[]"). **Finds or
+  # creates** the {Squash::Java::Type Type}, and **always creates** a new
+  # Argument.
+  #
+  # @param [String] type_descriptor The type description.
+  # @return [Squash::Java::Argument] The argument object, unbound to any
+  #   {Squash::Java::Method Method}.
+
+  def argument(type_descriptor)
+    array     = type_descriptor[-2..-1] == '[]'
+    type_name = type_descriptor.sub(/\[\]$/, '')
+    Squash::Java::Argument.new type(type_name), array
+  end
+
+  # Creates a new Argument for a given type descriptor, which can be fully or
+  # partially obfuscated. This can be an unobfuscated primitive (e.g., "float")
+  # or a possibly-obfuscated full class name (e.g., "com.foo.A"), and can be a
+  # scalar or an array (e.g., "float[]" or "com.foo.A[]"). **Finds** the
+  # {Squash::Java::Type Type}, and **always creates** a new Argument. Returns
+  # `nil` for unknown types.
+  #
+  # @param [String] type_descriptor The type description.
+  # @return [Squash::Java::Argument, nil] The argument object, unbound to any
+  #   {Squash::Java::Method Method}, or `nil` if the type is not recognized.
+
+  def obfuscated_argument(type_descriptor)
+    array     = type_descriptor[-2..-1] == '[]'
+    type_name = type_descriptor.sub(/\[\]$/, '')
+    type      = obfuscated_type(type_name)
+    return nil unless type
+    Squash::Java::Argument.new type, array
+  end
+end
+
+# Represents a Java package.
+
+class Squash::Java::Package
+
+  # @return [String] The last part of the package name (e.g., "bar" for package
+  #   "com.foo.bar").
+  attr_reader :name
+
+  # @return [String, nil] The obfuscated package name (e.g., "A" for
+  #   "com.foo.A").
+  attr_reader :obfuscation
+
+  # Sets the method's obfuscation.
+  # @raise [ArgumentError] If the obfuscation is taken by another class or in
+  #   package the same namespace.
+
+  def obfuscation=(name)
+    if (package = parent.children.detect { |p| p.obfuscation == name })
+      raise ArgumentError, "Tried to assign obfuscation #{name} to #{package.inspect} and #{inspect}"
+    end
+    @obfuscation = name
+  end
+
+  # @return [Squash::Java::Package] The parent package (e.g., package "com.foo"
+  #   for "com.foo.bar").
+  attr_reader :parent
+
+  # @return [Array<Squash::Java::Package>] Packages nested underneath this
+  #   package (see {#parent}).
+  attr_reader :children
+
+  # @return [Array<Squash::Java::Class>] Classes belonging to this package.
+  attr_reader :classes
+
+  # @private
+  def initialize(name, parent=nil)
+    @name   = name
+    @parent = parent
+    @parent.children << self if @parent
+    @children = Set.new
+    @classes  = Set.new
+  end
+
+  # **Finds** a package underneath this package.
+  #
+  # @param [String] identifier The package name relative to this package. If
+  #   finding package "com.foo.bar", pass "foo.bar" to Package "com".
+  # @return [Squash::Java::Package, nil] The matching package, if found.
+
+  def find(identifier)
+    parts = identifier.split('.')
+    name  = parts.shift
+    child = children.detect { |pkg| pkg.name == name }
+    if parts.empty?
+      child
+    else
+      child ? child.find(parts.join('.')) : nil
+    end
+  end
+
+  # **Finds** a package by obfuscated (or non-obfuscated) name relative to this
+  # package.
+  #
+  # @param [String] identifier The package name relative to this package (parts
+  #   may be obfuscated). If finding package "com.A.B", pass "A.B" to package
+  #   "com".
+  # @return [Squash::Java::Package, nil] The matching package, if found.
+
+  def find_obfuscated(identifier)
+    parts = identifier.split('.')
+    name  = parts.shift
+    child = children.detect { |pkg| pkg.obfuscation == name || pkg.name == name }
+    if parts.empty?
+      child
+    else
+      child ? child.find_obfuscated(parts.join('.')) : nil
+    end
+  end
+
+  # **Finds or creates** A package underneath this package.
+  #
+  # @param [String] identifier The package name relative to this package. If
+  #   finding package "com.foo.bar", pass "foo.bar" to Package "com".
+  # @return [Squash::Java::Package] The matching package, or the newly created
+  #   package.
+
+  def find_or_create(identifier)
+    parts = identifier.split('.')
+    name  = parts.shift
+
+    if ('A'..'Z').include? name[0, 1] # class
+      raise "Unexpected class midway through identifier" unless parts.empty?
+      classes.detect { |cl| cl.name == name } || Squash::Java::Class.new(self, name)
+    else # package
+      child = children.detect { |pkg| pkg.name == name } || Squash::Java::Package.new(name, self)
+      parts.empty? ? child : child.find_or_create(parts.join('.'))
+    end
+  end
+
+  # @return [String] The full name of this package (e.g., "com.foo.bar").
+  def full_name() parent ? "#{parent.full_name}.#{name}" : name end
+
+  # @private
+  def inspect() "#<#{self.class.to_s} #{full_name}>" end
+
+  # @private
+  def subpath() parent ? "#{parent.subpath}/#{name}" : name end
+end
+
+# Superclass describing both {Squash::Java::Primitive Primitive} types and
+# {Squash::Java::Class Classes}.
+
+class Squash::Java::Type
+  # @return [String] The type name.
+  attr_reader :name
+
+  # @return [String] The full type name. By default this is equal to {#name},
+  #   but can be overridden.
+  def full_name() name end
+
+  # @private
+  def inspect() "#<#{self.class.to_s} #{full_name}>" end
+end
+
+# Represents a Java class or inner class.
+
+class Squash::Java::Class < Squash::Java::Type
+  # @return [Squash::Java::Class, Squash::Java::Package] The parent package (or
+  #   parent class for inner classes).
+  attr_reader :parent
+
+  # @return [String, nil] The obfuscated name of this class.
+  attr_accessor :obfuscation
+
+  # @return [Array<Squash::Java::Method>] The instance methods of this class.
+  attr_reader :java_methods
+
+  # @return [Array<Squash::Java::Class>] The inner classes of this class.
+  attr_reader :classes
+
+  # @return [String] The path to the .java file defining this class, relative to
+  #   the project root.
+  # @see Squash::Java::Namespace#find_files
+  attr_accessor :path
+
+  # @private
+  def initialize(parent, name)
+    @parent       = parent
+    @java_methods = Set.new
+    @classes      = Array.new
+    @name         = name
+
+    @parent.classes << self
+  end
+
+  # @return [String] The name of this class (with package and parent class
+  #   names).
+
+  def full_name
+    "#{parent.full_name}.#{name}"
+  end
+
+  # @private
+  def subpath() parent.kind_of?(Squash::Java::Package) ? "#{parent.subpath}/#{name}.java" : parent.subpath end
+end
+
+# Represents a primitive Java type, like `int` or `float`.
+
+class Squash::Java::Primitive < Squash::Java::Type
+
+  # @private
+  def initialize(name)
+    @name = name
+  end
+end
+
+# Represents a Java instance method. Polymorphism is handled by using separate
+# Method instances with different {#arguments} values.
+
+class Squash::Java::Method
+  # @return [Squash::Java::Class] The class owning this method.
+  attr_reader :klass
+
+  # @return [Squash::Java::Argument] The type of object returned.
+  attr_reader :return_type
+
+  # @return [String] The method name.
+  attr_reader :name
+
+  # @return [Array<Squash::Java::Argument>] The method arguments.
+  attr_reader :arguments
+
+  # @return [String, nil] The obfuscated method name.
+  attr_reader :obfuscation
+
+  # Sets the method's obfuscation.
+  # @raise [ArgumentError] If the obfuscation is taken by another method in
+  #   the same class.
+
+  def obfuscation=(name)
+    if (meth = klass.java_methods.detect { |m| m.arguments == arguments && m.obfuscation == name })
+      raise ArgumentError, "Tried to assign obfuscation #{name} to #{meth.inspect} and #{inspect}"
+    end
+    @obfuscation = name
+  end
+
+  # @private
+  def initialize(klass, name, return_type, *arguments)
+    @klass       = klass
+    @name        = name
+    @return_type = return_type
+    @arguments   = arguments
+    klass.java_methods << self
+  end
+
+  # @private
+  def add_argument(type)
+    @arguments << type
+    @arguments.size - 1
+  end
+
+  # @return [String] The full method name, along with return value and arguments
+  #   as full type names.
+
+  def full_name
+    args = arguments.map { |type| type.to_s }.join(', ')
+    "#{return_type.full_name} #{name}(#{args})"
+  end
+
+  # @private
+  def inspect() "#<#{self.class.to_s} #{full_name}>" end
+end
+
+# A {Squash::Java::Method Method} argument. Includes the argument
+# {Squash::Java::Type} and whether it is a scalar or an array.
+
+class Squash::Java::Argument
+  # @return [Squash::Java::Type] The argument type.
+  attr_reader :type
+
+  # @return [true, false] `true` if the argument is an array, false if it is a
+  #   scalar.
+  attr_reader :array
+  alias array? array
+
+  # @private
+  def initialize(type, array=false)
+    @type  = type
+    @array = array
+  end
+
+  # @private
+  def ==(other)
+    other.kind_of?(Squash::Java::Argument) &&
+        type == other.type &&
+        array? == other.array?
+  end
+
+  # @return [String] The type's full name, with "[]" appended for arrays.
+  def to_s() "#{type.full_name}#{'[]' if array?}" end
+
+  # @private
+  def inspect() "#<#{self.class} #{to_s}>" end
+end
+
+# All known Java primitives.
+Squash::Java::PRIMITIVES = %w(boolean byte char short int long float double void).map { |name| Squash::Java::Primitive.new name }

data/lib/squash/java/rename_log.rb

@@ -0,0 +1,119 @@
+# Copyright 2012 Square Inc.
+#
+#    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
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+require 'rexml/document'
+
+# Parses a rename log file (generated from yGuard or ProGuard) and generates a
+# {Squash::Java::Namespace} object from it.
+
+class Squash::Java::RenameLog
+  # @private
+  JAVA_PACKAGE_COMPONENT = '[a-z][a-z0-9_]*'
+  # @private
+  JAVA_PACKAGE_NAME = "#{JAVA_PACKAGE_COMPONENT}(?:\\.#{JAVA_PACKAGE_COMPONENT})*"
+  # @private
+  JAVA_CLASS_NAME = JAVA_VARIABLE_NAME = JAVA_OBFUSCATED_NAME = JAVA_METHOD_NAME = "[A-Za-z0-9_$]+"
+  # @private
+  JAVA_CLASS_PATH = "(?:#{JAVA_PACKAGE_NAME}\\.)?#{JAVA_CLASS_NAME}"
+  # @private
+  JAVA_PRIMITIVE = '(?:boolean|byte|char|short|int|long|float|double|void)'
+  # @private
+  JAVA_TYPE = "(?:#{JAVA_PRIMITIVE}|#{JAVA_CLASS_PATH})(?:\\[\\])*"
+  # @private
+  JAVA_TYPE_LIST = "#{JAVA_TYPE}(?:,\\s?#{JAVA_TYPE})*"
+  # @private
+  JAVA_METHOD_SIGNATURE = "#{JAVA_TYPE} #{JAVA_METHOD_NAME}\\((?:#{JAVA_TYPE_LIST})?\\)"
+
+  # Creates a new parser for a given rename log file. The file is assumed to be
+  # in the yGuard format if it ends in ".xml", and in the ProGuard format if it
+  # ends in ".txt".
+  #
+  # @param [String] logfile The path to a rename log file.
+
+  def initialize(logfile)
+    @logfile = logfile
+  end
+
+  # @return [Squash::Java::Namespace] The name mapping in the file.
+
+  def parse
+    return parse_yguard if File.extname(@logfile) == '.xml'
+    return parse_proguard if File.extname(@logfile) == '.txt'
+  end
+
+  private
+
+  def parse_yguard
+    namespace = Squash::Java::Namespace.new
+
+    xml = REXML::Document.new(File.new(@logfile))
+    xml.elements.each("//yguard/map/*") do |element|
+      obfuscation = element.attributes['map']
+      name        = element.attributes['name']
+      case element.name
+        when 'package'
+          namespace.add_package_alias name, obfuscation
+        when 'class'
+          # "com.hvilela.Wallpaperer$6" gets an obfuscation of "6" when it should be "Wallpaperer$6"
+          class_name = name.split('.').last
+          if class_name.include?('$')
+            base_class = namespace.klass(class_name.split('$').first)
+            new_obfuscation = [base_class.obfuscation || base_class.name]
+            new_obfuscation += class_name.split('$')[1..-2] << obfuscation
+            obfuscation = new_obfuscation.join('$')
+          end
+          namespace.add_class_alias name, obfuscation
+        when 'method'
+          namespace.add_method_alias element.attributes['class'], name, obfuscation
+      end
+    end
+
+    xml.elements.each("//yguard/expose/class") do |element|
+      name = element.attributes['name']
+      namespace.klass name
+    end
+
+    return namespace
+  end
+
+  def parse_proguard
+    namespace = Squash::Java::Namespace.new
+
+    File.open(@logfile) do |f|
+      current_class = nil
+      f.each_line do |line|
+        if line =~ /^(#{JAVA_CLASS_PATH}) -> (#{JAVA_CLASS_PATH}):$/ # class
+          current_class = namespace.add_class_alias($1, $2.split('.').last)
+        elsif line =~ /^    #{JAVA_TYPE} #{JAVA_VARIABLE_NAME} -> #{JAVA_OBFUSCATED_NAME}$/ # field, skip
+          raise "Unexpected field mapping outside of class" unless current_class
+        elsif line =~ /^    (?:\d+:\d+:)?(#{JAVA_METHOD_SIGNATURE}) -> (#{JAVA_OBFUSCATED_NAME})$/ # method
+          raise "Unexpected method mapping outside of class" unless current_class
+          begin
+            namespace.add_method_alias(current_class, $1, $2) if current_class.kind_of?(Squash::Java::Class)
+          rescue ArgumentError
+            # duplicate obfuscation -- this happens when the Java compiler
+            # generates multiple methods with the same signature to support
+            # generics. ignore the less specific variant (all later variants)
+            raise unless $!.to_s =~ /Tried to assign obfuscation/
+          end
+        elsif line.empty? # blank, skip
+        else
+          raise "Invalid mapping line: #{line}"
+        end
+      end
+    end
+
+    return namespace
+  end
+end

data/lib/squash/java.rb

@@ -0,0 +1,26 @@
+# Copyright 2012 Square Inc.
+#
+#    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
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+# Container module for Squash-related code.
+
+module Squash
+
+  # Container module for Squash Java-related code.
+
+  module Java
+  end
+end
+
+require 'squash/java/namespace'
+require 'squash/java/rename_log'

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification 
+name: squash_java
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Tim Morgan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-12-07 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  name: json
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  name: squash_uploader
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  name: rspec
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  name: yard
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  name: redcarpet
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  name: jeweler
+  version_requirements: *id006
+description: This gem includes a library that imports yGuard or ProGuard rename logs, and a binary that uploads the data to Squash.
+email: tim@squareup.com
+executables: 
+- squash_release
+- deobfuscate
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.md
+files: 
+- LICENSE.txt
+- README.md
+- bin/deobfuscate
+- bin/squash_release
+- lib/squash/java.rb
+- lib/squash/java/namespace.rb
+- lib/squash/java/rename_log.rb
+homepage: http://github.com/SquareSquash/java_deobfuscator
+licenses: 
+- Apache 2.0
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Binary and library for deobfuscating your Java project and uploading the rename log to Squash.
+test_files: []
+