picatrix 0.5.0 → 0.5.5

data/lib/picatrix/jenny.rb

@@ -26,30 +26,56 @@ module Picatrix
       @meta = {}
 
       if File.exist?(
-          mason_path = "lib/picatrix/generated/mason/namespaces.json"
+          namespaces_path = "generated/#{app_name}/support/namespaces.json"
       ) #TODO this should be coming in from graph instead
         @namespaces = JSON.parse(
           File.read(
-            mason_path
+            namespaces_path
           )
         )
         @prefix = "#{@namespaces["@namespaces"].keys.first}:"
       else
-        puts "no generated/mason/namespaces.json file"
+        puts "no generated/#{app_name}/support/namespaces.json file"
         @namespaces = {}
         @prefix = ""
       end
+    end
+
+    def just_do_it
+      setup_framework_for(app_name)
+      generate_sinatra_of(app_name)
+    end
+
+    def setup_framework_for(app_name)
+      template(
+        'templates/mason.rb',
+        File.join("../../generated/#{app_name}/support/mason.rb")
+      )
+
+      Protoc.to_ruby(app_name)
+
+      begin
+        jenny_path = File.dirname( __FILE__ )
+        $:.unshift File.expand_path( File.join( jenny_path, "..", "..", "generated" ) )
+        $:.unshift File.expand_path( File.join( jenny_path, "..", "..", "generated", "#{app_name}" ) )
+        $:.unshift File.expand_path( File.join( jenny_path, "..", "..", "generated", "#{app_name}", "support" ) )
+
+        require_all("./generated/#{app_name}/**/*.rb")
+      rescue LoadError => e
+        puts "#{e}"
+      end
 
       @control_templates = Cruddy.new(@edges).controls
+      @resources = Prototyper.new(@nodes, {}, app_name).resources
       @routes = Routes.new(@edges, @control_templates)
       # make this available to the app scope
       @root_path = @routes.root_path
     end
 
-    def just_do_it
+    def generate_sinatra_of(app_name)
       template(
         'templates/app.rb',
-        File.join("generated/#{app_name}.rb")
+        File.join("../../generated/#{app_name}/#{app_name}.rb")
       )
     end
 

data/lib/picatrix/link_relation_index.rb

@@ -5,7 +5,7 @@ module Picatrix
       @as_hash = {
         link_relations: edges.flat_map do |e|
           source = e.first.at(0)
-          link_relation = e.first.at(1)[:link_relation].delete('"')
+          link_relation = e.first.at(1)[:link_relation]
 
           {
             link_relation.to_sym => "#{source} -(#{e.first.at(1)[:method].upcase})-> #{e.first.at(1)[:target]}"

data/lib/picatrix/pacman.rb

@@ -2,21 +2,27 @@ module Picatrix
   # eats dots :)
   # and gives you back nodes and edges
   class Pacman
-    attr_accessor :hash
     attr_accessor :nodes, :edges
 
     def initialize(file_name)
-      @hash = TransformToHash.new.apply(
+      hash = TransformToHash.new.apply(
         DigraphParser.new.parse(
           File.read(file_name)
         )
       ).flat_map(&:entries).
       group_by(&:first).
-      map {|k,v| Hash[k, v.map(&:last)]}
+      map {|k,v| Hash[k, v.map(&:last)]}.
+      reduce({}, :merge)
 
-      grouped = @hash.group_by {|e| e.keys.first}
-      @nodes = grouped[:node].flat_map {|e| e[:node]}.reduce({}, :merge)
-      @edges = grouped[:edge].flat_map {|e| e[:edge]}
+      @nodes = hash[:node].reduce({}, :merge)
+      @edges = hash[:edge]
+    end
+
+    def graph_hash
+      {
+        node: nodes,
+        edge: edges
+      }
     end
   end
 end

data/lib/picatrix/protoc.rb

@@ -0,0 +1,7 @@
+module Picatrix
+  module Protoc
+    def self.to_ruby(app_name)
+      `protoc -I ./lib/picatrix/support -I ./generated/#{app_name}/support --ruby_out ./generated/#{app_name}/support generated/#{app_name}/support/#{app_name}.proto`
+    end
+  end
+end

data/lib/picatrix/prototyper.rb

@@ -0,0 +1,56 @@
+require 'protobuf'
+require 'faker'
+
+module Picatrix
+  class Prototyper
+    include Thor::Base
+    include Thor::Actions
+
+    attr_accessor :destination_stack, :options,
+      :resources
+
+    source_root File.dirname(__FILE__)
+
+    PROTOBUF_FIXTURES = {
+      Protobuf::Field::Int32Field => "Faker::Number.number(6)",
+      Protobuf::Field::StringField => "Faker::Lorem.word"
+    }
+
+    def initialize(nodes, options = {}, app_name = "app")
+      # thor related
+      @options = options
+      @destination_stack = [self.class.source_root]
+
+      @resources = nodes.keys.select {|n| n if n.pluralize == n}
+      resources.each do |resource|
+        @resource_name = resource.camelize
+        @fields = @resource_name.singularize.
+          constantize.fields.inject({}) do |memo, field|
+
+          field_value =
+            if PROTOBUF_FIXTURES[field.type_class]
+              # TODO this is too general need some way to signal
+              # primary key which is addressable
+              if field.name.to_s.include?("id")
+                "id = #{PROTOBUF_FIXTURES[field.type_class]}"
+              else
+                PROTOBUF_FIXTURES[field.type_class]
+              end
+            elsif field.type_class.to_s.demodulize == "Controls"
+              "#{field.type_class}.new(minimal_controls_for(item_id))"
+            else
+              # TODO recursively gen these relations
+              "[#{field.type_class}.new(params = {})]"
+            end
+
+          memo[field.name] = field_value
+          memo
+        end
+        template(
+          'templates/type.rb',
+          File.join("../../generated/#{app_name}/resources/#{resource}.rb")
+        )
+      end
+    end
+  end
+end

data/lib/picatrix/routes.rb

@@ -2,39 +2,68 @@ module Picatrix
   # this class is the data structure you'll construct the Sinatra
   # routes and their corresponding handling method bodies
   class Routes
-    attr_accessor :unique_routes, :root_path
+    attr_accessor :unique_routes, :root_path, :controls
 
     def initialize(edges, control_templates)
+      @controls = {}
+
+      edges.collect do |edge|
+        edge.values.first[:target]
+      end.each do |resource|
+        if (control = control_templates[resource])
+          @controls.merge!(control.to_hash)
+        end
+      end
+
       @unique_routes = edges.collect do |edge|
         source = edge.keys.first
         target = edge.values.first[:target]
         properties = edge[source]
 
-        link_relation = properties[:link_relation].delete('"')
+        link_relation = properties[:link_relation]
 
         if source == "root"
           #TODO right now app is using this in place of
           # figuring out parent collections of collections
           @root_path = target
+          source = target
         end
 
-        templates = {}
-        if (control = control_templates[target])
-          templates.merge!(control.to_hash)
-        end
+        path = case properties[:method]
+               when :post
+                 source.pluralize
+               when :get
+                 if is_collection?(target)
+                   "#{source.pluralize}"
+                 else
+                   "#{source.pluralize}/#{link_relation}"
+                 end
+               when :patch
+                 "#{source.pluralize}/:item_id"
+               when :put
+                 "#{source.pluralize}/:item_id"
+               when :delete
+                 "#{source.pluralize}/:item_id"
+               else
+                 "#{source.pluralize}/#{link_relation}"
+               end
 
         {
-          path: target,
+          path: path,
+          target: target,
           link_relation: link_relation,
           method: properties[:method],
-          resource: {
+          response_resource: {
             name: target.camelcase.constantize,
-            collection: (target == target.pluralize)
-          },
-          control_templates: templates
+            collection: is_collection?(target)
+          }
         }
         # make sure routes are not duplicated
       end.compact.uniq {|e| [e[:path], e[:method]]}
     end
+
+    def is_collection?(target)
+      (target == target.pluralize)
+    end
   end
 end

data/{definitions/mason.proto → lib/picatrix/support/picatrix.mason.proto}

@@ -1,5 +1,6 @@
-package mason;
+package picatrix.mason;
 
+// TODO this doesnt really make sense as enum, should deprecate
 enum HTTPVerb {
   GET = 1;
   PUT = 2;
@@ -18,37 +19,39 @@ message Up {
   optional string title = 2;
 }
 
-// Filter should be broken out into custom Picatrix stuff
-// as it's not really part of the Mason spec
 message Filter {
-  enum HrefTemplate {
-    TRUE = 0;
-    FALSE = 1;
-  }
-
   optional string href = 1;
-  optional HTTPVerb method = 2 [default = GET];
-  optional HrefTemplate isHrefTemplate = 3 [default = TRUE];
+  required HTTPVerb method = 2 [default = GET];
+  required bool isHrefTemplate = 3 [default = true];
+  optional string title = 4;
+
+  extensions 10 to 19;
 }
 
 message Create {
   optional string href = 1;
-  optional HTTPVerb method = 2 [default = POST];
+  required HTTPVerb method = 2 [default = POST];
   optional string title = 3;
   optional string encoding = 4;
+
+  extensions 10 to 19;
 }
 
 message Edit {
   optional string href = 1;
-  optional HTTPVerb method = 2 [default = PATCH];
+  required HTTPVerb method = 2 [default = PATCH];
   optional string title = 3;
   optional string encoding = 4;
+
+  extensions 10 to 19;
 }
 
 message Remove {
   optional string href = 1;
-  optional HTTPVerb method = 2 [default = DELETE];
+  required HTTPVerb method = 2 [default = DELETE];
   optional string title = 3;
+
+  extensions 10 to 19;
 }
 
 // when viewing an item directly, you see

data/lib/picatrix/templates/app.proto

@@ -0,0 +1,42 @@
+import "picatrix.mason.proto";
+
+// representation objects
+<% @representation_klasses.each do |klass| %>
+message <%= klass %> {
+  optional int32 id = 1;
+
+  message Controls {
+    optional picatrix.mason.Self self = 1;
+  }
+
+  optional Controls controls = 2;
+<% if klass.pluralize == klass %>
+  repeated <%= klass.singularize.camelcase %> collection = 3;
+<% end %>
+}
+<% end %>
+
+// generic CRUFD controls to extend
+<% @item_representations.each do |item| %>// per item representation
+<% ITEM_ACTIONS.each do |action| %>
+message <%= item %><%= action %>Template {
+}
+extend picatrix.mason.<%= action %> {
+  optional <%= item %><%= action %>Template <%= action.underscore %>_template = 10;
+}
+<% end %>
+<% end %>
+<% @col_representations.each do |item| %>// per collection representation
+<% COL_ACTIONS.each do |action| %>
+message <%= item %><%= action %>Template {
+}
+extend picatrix.mason.<%= action %> {
+  optional <%= item %><%= action %>Template <%= action.underscore %>_template = 10;
+}
+<% end %>
+<% end %>
+// totally custom controls
+<% @link_relations.each do |link_relation| %>
+message <%= link_relation %> {
+}
+<% end %>

data/lib/picatrix/templates/app.rb

@@ -3,9 +3,18 @@ require 'sinatra/json'
 require 'protobuf'
 require 'require_all'
 
-require_all("./lib/picatrix/generated/*.rb")
+$:.unshift(File.join(File.dirname(__FILE__)))
+$:.unshift(File.join(File.dirname(__FILE__), 'support'))
+$:.unshift(File.join(File.dirname(__FILE__), 'resources'))
+
+require("./generated/<%= @app_name %>/support/picatrix.mason.pb")
+require("./generated/<%= @app_name %>/support/mason")
+require("./generated/<%= @app_name %>/support/<%= @app_name %>.pb")
+require_all("generated/<%= @app_name %>/resources/*.rb")
 
 class <%= @app_name.camelize %> < Sinatra::Base
+  include Picatrix::Mason
+
   set :public_folder => "public", :static => true
 
   get '/rels' do
@@ -23,142 +32,21 @@ class <%= @app_name.camelize %> < Sinatra::Base
   end
 
 <% @routes.unique_routes.each do |route| %>
-<% if route[:resource][:collection] %>
-   <%= route[:method] %> "/<%= route[:path] %>" do
-     items = <%= route[:resource][:name] %>Resource.all.collection.collect do |r|
-       r.to_hash
-     end
-
-     <% if route[:control_templates][route[:path]][route[:method]] %>
-     controls = send(:<%= route[:control_templates][route[:path]][route[:method]] %>, <%= route[:resource][:name] %>).call("<%= route[:path] %>", params)
-     <% else %>
-     controls = {}
-     <% end %>
-
-     json(
-       {:@controls => controls}.
-        merge!({"<%= route[:resource][:name].to_s.underscore %>" => items})
-     )
-   end
-  <% else %>
-   <%= route[:method] %> "/<%= route[:path] %>/:item_id" do
-     item = <%= route[:resource][:name].to_s.pluralize.constantize %>Resource.<%= send_method_for(route[:method]).to_s %>(params[:item_id])
-
-     <% if route[:control_templates][route[:path]][route[:method]] %>
-     controls = send(:<%= route[:control_templates][route[:path]][route[:method]] %>, <%= route[:resource][:name] %>).call("<%= route[:path] %>", params)
-     <% else %>
+<%= route[:method] %> "/<%= route[:path] %>" do
+<% if route[:response_resource][:collection] %>
+     response_body = {"<%= route[:response_resource][:name].to_s.underscore %>" => <%= route[:response_resource][:name] %>Resource.as_hashes}
+<% else %>
+     response_body = <%= route[:response_resource][:name].to_s.pluralize.constantize %>Resource.<%= send_method_for(route[:method]).to_s %>(params[:item_id]).to_hash.except(:controls)
+<% end %>
      controls = {}
-     <% end %>
-
-     json(
-       {:@controls => controls}.
-        merge!(item.to_hash.except(:controls))
-     )
+<% if @routes.controls[route[:target]][route[:method]] %>
+<% @routes.controls[route[:target]][route[:method]].each do |control| %>
+     controls.merge!(send("<%= control %>".to_sym, <%= route[:response_resource][:name] %>).call("<%= route[:target] %>".pluralize, params))
+<% end %>
+<% end %>
+     json({
+       :@controls => controls
+     }.merge!(response_body))
    end
-  <% end %>
 <% end %>
-
-  def mason_up(type)
-    if type == collection
-      proc do |path, params|
-        {
-          up: Mason::Up.new(
-            {
-              href: "http://localhost:9292/#{<%= @root_path %>}"
-            }
-          ).to_hash
-        }
-      end
-    else
-      proc do |path, params|
-        {
-          up: Mason::Up.new(
-            {
-              href: "http://localhost:9292/#{path}"
-            }
-          ).to_hash
-        }
-      end
-    end
-  end
-  def mason_self(item)
-      proc do |path, params|
-        if params[:item_id]
-          {
-            self: Mason::Self.new(
-              {
-                href: "http://localhost:9292/#{path}/#{params[:item_id]}"
-              }
-            ).to_hash
-          }
-        else
-          {
-            self: Mason::Self.new(
-              {
-                href: "http://localhost:9292/#{path}"
-              }
-            ).to_hash
-          }
-        end
-      end
-  end
-  def edit(item)
-      proc do |path, params|
-        {
-          edit: ("Edit" + item.to_s.singularize.camelize).constantize.new(
-            {
-              form: Mason::Edit.new(
-                href: "http://localhost:9292/#{path}/#{params[:item_id]}"
-              )
-            }
-          ).to_hash
-        }
-      end
-  end
-  def remove(item)
-      proc do |path, params|
-        {
-          remove: Mason::Remove.new(
-            {
-              href: "http://localhost:9292/#{path}/#{params[:item_id]}"
-            }
-          ).to_hash
-        }
-      end
-  end
-  def create(item)
-      proc do |path, params|
-        {
-          create: ("Create" + item.to_s.singularize.camelize).constantize.new(
-            {
-              form: Mason::Create.new(
-                href: ""
-              )
-            }
-          )
-        }
-      end
-  end
-  def filter(collection)
-    # TODO this prob cant really work here
-      proc do |path, params|
-        if params[:item_id]
-          {
-            "<%= @prefix %>filter": Mason::Filter.new(
-              {
-                href: "http://localhost:9292/#{path}/#{params[:item_id]}"
-              }
-            ).to_hash
-          }
-        else
-          {
-            "<%= @prefix %>filter": Mason::Filter.new(
-              {
-                href: "http://localhost:9292/#{path}"
-              }
-            ).to_hash
-          }
-      end
-    end
-  end
 end