society 0.13.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8f65f593c46ae32062a78ec4c22aaf53f55f7436
-  data.tar.gz: 7f39c3d8b353ff9ad94568abcc690c90a5b878b7
+  metadata.gz: 6e981e4f78cf210bc9a370f895b47f44b66f48a1
+  data.tar.gz: 164a11a1e55e5921ca3dc32c58afbf984f09427f
 SHA512:
-  metadata.gz: 109d6b030877005b7246c2702312cbac6213d9687b06d2e573ddfcb617cc5ec528f40db2799773800ba365666a965c0b8c3a60e49a2a23bfd8cf8c1af1001385
-  data.tar.gz: 46b91d5ee61b7056f8709d03b1d0dc607482b7d53ac6d758b2b3f8813b4035cf66aebfa9a65debcbf0d37283b02759c8f35ac7efb08c47d23e635d3e9f11b538
+  metadata.gz: fb27a9fe4c863f8acd5ff810ab0d5c37be1f22082f1f1e412a7349c58ed4e616631a8852f60eb7f6fc8a96ac254266e56a509aa43e51274fc22a162cea206a88
+  data.tar.gz: f5859b87ee2efd9e3456c488298f0e2fe6d67ed25bfa497e56e42ea7b6a0710925584289c62d62d0621f7cac873c1549c833d7388391678348176bd79a0cb116

data/.bowerrc

@@ -0,0 +1,3 @@
+{
+  "directory": "lib/society/formatter/report/templates/components"
+}

data/.gitignore

@@ -1,23 +1,11 @@
-*.gem
-*.rbc
 .bundle
 .config
-.yardoc
 Gemfile.lock
-InstalledFiles
-_yardoc
 coverage
-doc/
-lib/bundler/man
 pkg
 rdoc
 spec/reports
-test/tmp
-test/version_tmp
 tmp
-*.bundle
-*.so
-*.o
-*.a
-mkmf.log
 .console_history
+doc/society
+

data/README.md

@@ -1,6 +1,7 @@
 # Society
 
-Society analyzes and presents a social graph of relationships between classes or methods.
+Society analyzes and presents a social graph of relationships between classes or
+methods.
 
 ## Installation
 
@@ -18,31 +19,31 @@ Or install it yourself as:
 
 ## Usage
 
-Initialize a parser with source files:
+From your terminal:
 
-     parser = Society::Parser.new("path/to/models")
+    society from path/to/models
 
-Generate an object dependency graph:
+and then open `doc/society/index.htm` in your browser.
 
-     graph = parser.class_graph
+The default format is HTML; you can skip the HTML interface and just get the
+JSON by passing `--format json`
 
-Generate a method dependency graph:
+Note that all JSON data is timestamped (regardless of output format) to store
+snapshots of your project over time.
 
-     graph = parser.method_graph
+## Updating assets
 
-Generate JSON dependency matrix for export to d3:
-
-    parser.matrix.to_jsno
-
-## TODO
-
-* Add fukuzatsu as a dependency
-
-* Wrap fukuzatsu parsing and remove duplicate classes
+All JavaScript and CSS dependencies are checked into the repo, so any given
+commit should have everything it needs. However, if you're developing the gem
+and need to pull in updates from the
+[society-assets](https://github.com/CoralineAda/society-assets) package, you
+can do so on the command line with `$ bower update`.
 
 ## Contributing
 
-Please note that this project is released with a [Contributor Code of Conduct](https://github.com/Bantik/society/blob/master/CODE_OF_CONDUCT.md). By participating in this project you agree to abide by its terms.
+Please note that this project is released with a [Contributor Code of Conduct]
+(http://contributor-covenant.org/version/1/0/0/).
+By participating in this project you agree to abide by its terms.
 
 
 1. Fork it ( https://github.com/[my-github-username]/society/fork )

data/bower.json

@@ -0,0 +1,6 @@
+{
+  "name": "society",
+  "dependencies": {
+    "society-assets": "1.1.1"
+  }
+}

data/lib/society.rb

@@ -1,12 +1,22 @@
+require "analyst"
 require "fileutils"
+require "active_support/core_ext/string/inflections"
 
-module Society
-end
-
-require_relative "society/cli"
-require_relative "society/matrix"
-require_relative "society/node"
+require_relative "society/association_processor"
+require_relative "society/reference_processor"
+require_relative "society/edge"
+require_relative "society/formatter/graph/json"
+require_relative "society/formatter/report/html"
+require_relative "society/formatter/report/json"
 require_relative "society/object_graph"
 require_relative "society/parser"
 require_relative "society/version"
 
+module Society
+
+  def self.new(path_to_files)
+    Society::Parser.for_files(path_to_files)
+  end
+
+end
+

data/lib/society/association_processor.rb

@@ -0,0 +1,206 @@
+module Society
+
+  class AssociationProcessor
+
+    ACTIVE_MODEL_ASSOCIATIONS = %w[belongs_to has_one has_many has_and_belongs_to_many]
+
+    attr_reader :classes, :associations, :unresolved_associations
+
+    def initialize(classes)
+      @classes = classes
+      process
+    end
+
+    private
+
+    def process
+      default_resolver = DefaultResolver.new(classes)
+      through_resolver = ThroughResolver.new(classes)
+      poly_resolver = PolymorphicResolver.new(default_resolver)
+
+      classes.each do |klass|
+        klass.macros.select do |macro|
+          ACTIVE_MODEL_ASSOCIATIONS.include?(macro.name)
+          # TODO: make sure macro.target is 'self' (it pretty much always will be)
+        end.each do |association|
+          through_resolver.process(association, klass) or
+            poly_resolver.process(association, klass) or
+            default_resolver.process(association, klass)
+        end
+      end
+
+      @associations = default_resolver.associations
+      @unresolved_associations = default_resolver.unresolved_associations
+
+      @associations.concat(poly_resolver.associations).concat(through_resolver.associations)
+      @unresolved_associations.concat(through_resolver.unresolved_associations)
+    end
+
+
+    class ThroughResolver
+
+      attr_reader :associations, :unresolved_associations
+
+      def initialize(classes)
+        @classes = classes
+        @my_own_default_resolver = DefaultResolver.new(classes)
+        @associations = []
+        @unresolved_associations = []
+      end
+
+      def process(association, klass)
+        return false unless thru = through_of(association)
+
+        if source_type = association.arguments.last.to_hash[:source_type]
+          target = @classes.detect { |cls| cls.full_name == source_type }
+        else
+          joiner = klass.macros.detect do |macro|
+            ACTIVE_MODEL_ASSOCIATIONS.include?(macro.name) && macro.arguments.first.value == thru
+          end
+          joining_class_entities = @my_own_default_resolver.all_classes_for(joiner)
+
+          source_str = source_of(association).to_s
+
+          target = joining_class_entities.reduce(nil) do |_,cls|
+            assoc = find_association_in(cls, source_str)
+            break @my_own_default_resolver.process(assoc, cls) if assoc
+          end
+        end
+
+        if target
+          @associations << Edge.new(from: klass,
+                                    to: target,
+                                    meta: {
+                                      type: :through_association,
+                                      macro: association })
+        else
+          @unresolved_associations << { class: klass,
+                                        macro: association,
+                                        thru_macro: joiner,
+                                        joining_classes: joining_class_entities }
+        end
+        true
+      end
+
+      private
+
+      def find_association_in(klass, name)
+        klass.macros.detect do |macro|
+          ACTIVE_MODEL_ASSOCIATIONS.include?(macro.name) &&
+            macro.arguments.first.value.to_s.singularize == name.singularize
+        end
+      end
+
+      def through_of(association)
+        last_arg = association.arguments.last
+        last_arg.is_a?(Analyst::Entities::Hash) && last_arg.to_hash[:through]
+      end
+
+      def source_of(association)
+        association.arguments.last.to_hash[:source] || association.arguments.first.value
+      end
+
+    end
+
+
+    class DefaultResolver
+
+      attr_reader :associations, :unresolved_associations
+
+      def initialize(classes)
+        @classes = classes
+        @associations = []
+        @unresolved_associations = []
+      end
+
+      def process(association, klass)
+        if target = all_classes_for(association).first
+          @associations << Edge.new(from: klass,
+                                    to: target,
+                                    meta: {
+                                      type: :association,
+                                      macro: association })
+        else
+          @unresolved_associations << { class: klass,
+                                        target_name: target_class_name_for(association),
+                                        macro: association }
+        end
+        target
+      end
+
+      def all_classes_for(association)
+        target_name = target_class_name_for(association)
+        classes.select { |klass| klass.full_name == target_name }
+      end
+
+      private
+
+      attr_reader :classes
+
+      def target_class_name_for(association)
+        last_arg = association.arguments.last
+        if last_arg.is_a? Analyst::Entities::Hash
+          target_name = last_arg.to_hash[:class_name]
+        end
+        target_name ||= association.arguments.first.value.to_s.pluralize.classify
+      end
+
+    end
+
+
+    class PolymorphicResolver
+
+      def initialize(default_resolver)
+        @default_resolver = default_resolver
+        @polymorphics = []
+        @ases = []
+      end
+
+      # stores off any `polymorphic: true` or `as: :something` associations for
+      # later processing. also does default processing on `as: :something`
+      # associations. returns true iff association requires no further processing.
+      def process(association, klass)
+        last_arg = association.arguments.last
+        return false unless last_arg.is_a?(Analyst::Entities::Hash)
+
+        opts = last_arg.to_hash
+        if opts.key? :polymorphic
+          @polymorphics << { class: klass,
+                            key: association.arguments.first.value,
+                            macro: association }
+          return true
+
+        elsif opts.key? :as
+          if target = @default_resolver.process(association, klass)
+            @ases << { class: klass, target: target,
+                      macro: association, key: opts[:as] }
+          end
+          return true
+        end
+
+        false
+      end
+
+      def associations
+        associations = []
+        @polymorphics.each do |poly|
+          matching = @ases.select do |as|
+            as[:key] == poly[:key] && as[:target] == poly[:class]
+          end
+          matching.each do |as|
+            associations << Edge.new(from: poly[:class],
+                                      to: as[:class],
+                                      meta: {
+                                        type: :polymorphic_association,
+                                        macro: poly[:macro],
+                                        complement: as[:macro] })
+          end
+        end
+        associations
+      end
+    end
+
+  end
+
+end
+

data/lib/society/cli.rb

@@ -1,26 +1,29 @@
 require "thor"
+require "society"
 
 module Society
 
   class CLI < Thor
 
-    desc_text = ""
+    desc_text = "Formats are html (default) and json."
+    desc_text << "Example: society from foo/ -f json -o ./society_data.json"
 
-    desc "from PATH_TO_FILE", desc_text
-    def from(path="./")
-      parser = Society::Parser.new(path)
-      parser.parse_files
-      parser.report
+    desc "from PATH_TO_FILE [-f FORMAT] [-o OUTPUT_PATH]", desc_text
+    method_option :format, :type => :string, :default => 'html', :aliases => "-f"
+    method_option :output, :type => :string, :aliases => "-o"
+
+    def from(path)
+      Society.new(path).report(format, options['output'])
     end
 
     default_task :from
 
     private
 
-    def formatter
-      Formatters::Text
+    def format
+      options['format'] && options['format'].to_sym
     end
 
   end
 
-end
+end

data/lib/society/edge.rb

@@ -0,0 +1,15 @@
+module Society
+  class Edge
+
+    attr_reader :from, :to
+    attr_accessor :meta
+
+    def initialize(from:, to:, meta:nil)
+      @from = from
+      @to = to
+      @meta = meta
+    end
+
+  end
+
+end

data/lib/society/formatter/graph/json.rb

@@ -0,0 +1,44 @@
+require 'json'
+
+module Society
+  module Formatter
+    module Graph
+      class JSON
+
+        def initialize(graph)
+          @nodes = graph.nodes
+          @edges = graph.edges
+        end
+
+        def to_json
+          to_hash.to_json
+        end
+
+        def to_hash
+          {
+            nodes: node_names.map { |name| { name: name } },
+            edges: named_edges.map do |edge|
+              {
+                from: node_names.index(edge.from),
+                to: node_names.index(edge.to)
+              }
+            end
+          }
+        end
+
+        private
+
+        attr_reader :nodes, :edges
+
+        def node_names
+          @node_names ||= nodes.map(&:full_name).uniq
+        end
+
+        def named_edges
+          @named_edges ||= edges.map { |edge| Edge.new(from: edge.from.full_name, to: edge.to.full_name) }
+        end
+
+      end
+    end
+  end
+end