puncsig 0.0.1

data/README.md

@@ -0,0 +1,134 @@
+# puncsig: Punctuation Signatures
+
+## What Is This?
+
+Inspired by Ward Cunningham's [Signature Survey: A Method for Browsing
+Unfamiliar Code](http://c2.com/doc/SignatureSurvey/), "puncsig" is
+short for "punctuation signature": it parses ruby code, and shows you
+just the punctuation from the methods. It gives you a rough idea of
+the length of each method, and helps you spot similar methods.
+
+## Install
+
+In your Gemfile:
+
+```
+gem 'puncsig'
+```
+
+...or on your command line:
+
+```
+$ gem install puncsig
+```
+
+You know, the basics.
+
+## Use It
+
+In your rails app:
+
+```
+$ bundle exec rake -T puncsig
+rake puncsig:all          # Run puncsig on the whole app
+rake puncsig:controllers  # Run puncsig on just the controllers
+rake puncsig:helpers      # Run puncsig on just the helpers
+rake puncsig:lib          # Run puncsig on just the files in lib
+rake puncsig:models       # Run puncsig on just the models
+```
+
+TODO In a normal ruby app. It's not quite here yet, I want to separate
+it out a bit more. Coming soon, promise!
+
+## Example: rstat.us
+
+Just for fun, let's take a look at the [rstat.us
+source](https://github.com/hotsh/rstat.us). I chose rstat.us strictly
+because a) it was open-source ruby, and b) it cleanly installed, so
+whatever puncsig says about the source, that's a great start - and I
+gave up on several others, because I couldn't get them installed
+easily. We _all_ have code that needs some love, and I have much love
+for the people behind rstat.us.
+
+```
+$ be rake puncsig:models
+
+[...]
+
+app/models/salmon_author.rb
+author_attributes:  {:=>,:=>,:=>,:=>,:=>,:=>,:=>}==().==.==.==.&&==.&&==.&&==.&&==.&&==.
+avatar_url:         @..{||..==}..
+email:              =@.==
+initialize:         ()@=
+bio:                @..
+name:               @..
+uri:                @.
+username:           @.
+
+[...]
+
+app/models/user.rb
+no_malformed_username:                   (=~/[@!#$\%&()*,^~{}|`=:;\\\/\[\]\?]/).?&&(=~/^[.]/).?&&(=~/[.]$/).?&&(=~/[.]{,}/).?.(:,.,,.)
+send_mention_notification:               (,)=.:=>=.:=>=://#{.}/=::.(.())=..=.(..)=::.(.,.)=.(.,,{-=>/-+})
+edit_user_profile:                       ()[:].?[:].?[:]==[:].=[:]..=.==[:].=[:]..=[:].=[:].=[:].=[:]...
+following_url?:                          ()=.(:=>).?.?(://#{.}/)=[/\/\/(.+)$/,]=[.(:=>)].?!(&).?!
+send_unfollow_notification:              ()=.:=>=::.(.,..)=..=.(..)=::.(.,.)=.(.,,{-=>/-+})
+send_follow_notification:                ()=.:=>=::.(.,..)=..=.(..)=::.(.,.)=.(.,,{-=>/-+})
+
+[...]
+```
+
+Look at these two signatures from app/models/discussion_list.rb:
+
+```
+send_unfollow_notification:              ()=.:=>=::.(.,..)=..=.(..)=::.(.,.)=.(.,,{-=>/-+})
+send_follow_notification:                ()=.:=>=::.(.,..)=..=.(..)=::.(.,.)=.(.,,{-=>/-+})
+```
+
+There's clearly something similar about them. Here's the source:
+
+```
+  # Send Salmon notification so that the remote user
+  # knows this user is following them
+  def send_follow_notification(to_feed_id)
+    f = Feed.first :id => to_feed_id
+
+    salmon = OStatus::Salmon.from_follow(author.to_atom, f.author.to_atom)
+
+    envelope = salmon.to_xml self.to_rsa_keypair
+
+    # Send envelope to Author's Salmon endpoint
+    uri = URI.parse(f.author.salmon_url)
+    http = Net::HTTP.new(uri.host, uri.port)
+    res = http.post(uri.path, envelope, {"Content-Type" => "application/magic-envelope+xml"})
+  end
+
+  # Send Salmon notification so that the remote user
+  # knows this user has stopped following them
+  def send_unfollow_notification(to_feed_id)
+    f = Feed.first :id => to_feed_id
+
+    salmon = OStatus::Salmon.from_unfollow(author.to_atom, f.author.to_atom)
+
+    envelope = salmon.to_xml self.to_rsa_keypair
+
+    # Send envelope to Author's Salmon endpoint
+    uri = URI.parse(f.author.salmon_url)
+    http = Net::HTTP.new(uri.host, uri.port)
+    res = http.post(uri.path, envelope, {"Content-Type" => "application/magic-envelope+xml"})
+  end
+```
+
+Definitely some kind of duplication there, and these methods aren't
+right next to each other in the source.
+
+And it helps us find really long methods, like these bad boys:
+
+```
+app/models/update.rb
+generate_html:              =.().!(/([]?:\/\/\+[---\/}])/,<=\\>\\</>).!()||$=.(:=>/^#{$}$/,:=>/^#{$}$/)=..?(/)=://#{.}#{}#{$}<=#{}>@#{$}@#{$}</>$=.(:=>/^#{$}$/)=..?(/)=://#{.}#{}#{$}<=#{}>@#{$}</>.!(/(^|\+)#(\+)/)||#{$}<=/?=%#{$}>##{$}</>.=
+```
+
+## TODOS
+
+* break it up & test it a bit.

data/Rakefile

@@ -0,0 +1,4 @@
+require 'rake/testtask'
+
+Rake::TestTask.new
+task :default => :test

data/lib/puncsig.rb

@@ -0,0 +1,78 @@
+module Puncsig
+
+  class FileReport
+    attr_reader :filename
+
+    def initialize(filename, method_sigs)
+      @filename = filename
+      @method_sigs = method_sigs
+    end
+
+    def method_names
+      @method_sigs.keys
+    end
+
+    # Not sure this is how it'll end up...
+    def method_sigs
+      @method_sigs
+    end
+  end
+
+  class Parser
+    def parse(filename)
+      src = src(filename)
+      methods = methods(src)
+      method_sigs = Hash[*methods.map { |name, src| [name, puncsig(src)] }.flatten]
+      FileReport.new(filename, method_sigs)
+    end
+
+    private
+
+    def src(path)
+      File.read(path).gsub(/^\s*#.*$/, '')
+    end
+
+    # Note: for models, this ignores stuff like named_scopes, etc. That's ok for now, and maybe ok for later.
+    def methods(src)
+
+      # TODO This leaves out methods like [], <<, etc...maybe just check for first non-space?
+      method_sigs = /def\s+[a-z_!?.]+/
+      method_names = src.scan(method_sigs).map { |sig| sig.sub(/^def /, '') }
+
+      bodies = src.split(method_sigs)[1..-1]  # strip off first chunk, the class beginning
+
+      method_names.zip(bodies)
+    end
+
+    def puncsig(src)
+      src.gsub(/[a-z0-9'"_\s]/i, '')
+    end
+
+  end
+
+  class Report
+
+    def initialize(*filename_methods)
+      @filenames = filename_methods.flatten
+    end
+
+    def run
+      parser = Parser.new
+
+      @filenames.each do |filename|
+
+        file_report = parser.parse(filename)
+        len = file_report.method_names.map(&:size).max
+
+        puts file_report.filename
+        file_report.method_sigs.sort_by { |n, s| -s.size }.each do |name, sig|
+          print "#{name}:".ljust(len + 3)
+          puts sig
+        end
+        puts
+      end
+    end
+  end
+end
+
+require 'puncsig/railtie' if defined?(Rails)

data/lib/puncsig/railtie.rb

@@ -0,0 +1,12 @@
+require 'puncsig'
+require 'rails'
+
+module Puncsig
+  class Railtie < Rails::Railtie
+    railtie_name :puncsig
+
+    rake_tasks do
+      load "tasks/puncsig.rake"
+    end
+  end
+end

data/lib/puncsig/version.rb

@@ -0,0 +1,3 @@
+module Puncsig
+  VERSION = "0.0.1"
+end

data/lib/tasks/puncsig.rake

@@ -0,0 +1,51 @@
+require 'puncsig'
+
+namespace :puncsig do
+  desc "Run puncsig on the whole app"
+  task :all do
+    Puncsig::Report.new(controllers + models + helpers + lib).run
+  end
+
+  desc "Run puncsig on just the models"
+  task :models do
+    Puncsig::Report.new(models).run
+  end
+
+  desc "Run puncsig on just the controllers"
+  task :controllers do
+    Puncsig::Report.new(controllers).run
+  end
+
+  desc "Run puncsig on just the helpers"
+  task :helpers do
+    Puncsig::Report.new(helpers).run
+  end
+
+  desc "Run puncsig on just the files in lib"
+  task :lib do
+    Puncsig::Report.new(lib).run
+  end
+
+
+
+  def controllers
+    all_under("app/controllers")
+  end
+
+  def models
+    all_under("app/models")
+  end
+
+  def helpers
+    all_under("app/helpers")
+  end
+
+  def lib
+    all_under("lib")
+  end
+
+  def all_under(dir)
+    Dir.glob(File.join(dir, '**/*.rb'))
+  end
+
+end

data/puncsig.gemspec

@@ -0,0 +1,35 @@
+require './lib/puncsig/version'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'puncsig'
+  s.version = Puncsig::VERSION
+
+  s.summary = %{
+    PuncSig: Punctuation Signatures for your ruby methods
+  }.strip.gsub(/\s+/, ' ')
+
+  s.description = %{
+
+    A method's punctuation signature is its source, minus all letters,
+    numbers, and whitespace. It can help you find similar methods,
+    find long methods, and see how your methods are balanced.
+
+    PuncSig parses your ruby classes and prints a report on your
+    classes' punctuation signatures.
+
+  }.strip.gsub(/\s+/, ' ')
+
+  s.files = Dir['lib/**/*.rb'] + Dir['test/**/*.rb'] + %w[
+    README.md
+    Rakefile
+    lib/tasks/puncsig.rake
+    puncsig.gemspec
+  ]
+
+  s.require_path = 'lib'
+  s.required_ruby_version = ">= 1.8.7"
+
+  s.author = "Dan Bernier"
+  s.email = "danbernier@gmail.com"
+  s.homepage = "https://github.com/danbernier/puncsig"
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: puncsig
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Dan Bernier
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-31 00:00:00.000000000 Z
+dependencies: []
+description: A method's punctuation signature is its source, minus all letters, numbers,
+  and whitespace. It can help you find similar methods, find long methods, and see
+  how your methods are balanced. PuncSig parses your ruby classes and prints a report
+  on your classes' punctuation signatures.
+email: danbernier@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/puncsig/railtie.rb
+- lib/puncsig/version.rb
+- lib/puncsig.rb
+- README.md
+- Rakefile
+- lib/tasks/puncsig.rake
+- puncsig.gemspec
+homepage: https://github.com/danbernier/puncsig
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: ! 'PuncSig: Punctuation Signatures for your ruby methods'
+test_files: []