shopifydev 0.0.2 → 0.0.3

data/NEXTSTEPS.md

@@ -1,26 +1,45 @@
 # switch command
 
-should be some shortcuts
+Z(2013.06.06):
+  M, I think you should work on memoizing the shop array and the 'refresh'
+  command. That lag is killing me.
 
-switch cronin
+  You should take a look at switch.handle_choices and switch.handle_by_shop_type
+  I realized that the object we are calling @cfg is either:
+    a string, in which case we should keep going
+    a result object, in which case we should switch shops
 
-should look for shops in an app
+  So, in handle_choice we determine whether we present a new menu, or go
+  ahead and update the current shop
 
-switch with no arguments
-you get a list:
+  The result object gets a key "shop_type" that lets us know how to deal
+  with it. The behaviour for test_shop is already there, but if you could
+  implement the behaviour for local, I would be happy
 
-test shops:
-1. cronin
+  I wrote a bunch of comments around the commands.rb file, too, so feel free
+  to read those
 
-apps (development):
-1. metafieldseditor
-2. shipping
+M: should be some shortcuts
 
-apps (heroku):
-1. metafieldseditor
-2. shipping
+  switch cronin
 
-_pry_.switch
+  should look for shops in an app
+
+  switch with no arguments
+  you get a list:
+
+  test shops:
+  1. cronin
+
+  apps (development):
+  1. metafieldseditor
+  2. shipping
+
+  apps (heroku):
+  1. metafieldseditor
+  2. shipping
+
+Z: _pry_.switch
   Switch is a class, and every instance of Pry has an instance of Switch. This way we can
   access _pry_.switch. In the global scope there will be an object called 'switch' that will
   be an alias to _pry_.switch so that we can call its public methods. There will also be a 
@@ -39,11 +58,11 @@ _pry_.switch
 
   Or we can use tab completion to present the menu by invoking switch as a global object.
 
-````
+  ````
   [1] pry(main)> switch.m[TAB]
   switch.metafieldseditor switch.morfars-metafields
   [2] pry(main)> switch.mo[TAB]rfars-metafields
-````
+  ````
 
   to accomplish the same.
 
@@ -52,7 +71,7 @@ _pry_.switch
 
   So in a deep menu we might see:
 
-````
+  ````
   [1] pry(main)> switch
   current shop: none
 
@@ -79,7 +98,7 @@ _pry_.switch
   2. the thing you wanted
   [1] pry(main)> switch 2
   current shop: none switching to "the thing you wanted"...
-````
+  ````
 
 # To check out
 
@@ -89,8 +108,8 @@ https://github.com/cldwalker/bond
 
 # Menu of Shops in local apps
 - [x] run rake shops in chosen local app
-- [ ] display result of rake shops in a menu
-  - how do we handle this? do we use letters? or does switch command remember state (which menu was displayed last)? ie, what does ```switch 1``` mean? 
+- [x] display result of rake shops in a menu
+- [x] how do we handle this? do we use letters? or does switch command remember state (which menu was displayed last)? ie, what does ```switch 1``` mean? 
 - [ ] memoize results of rake shops in a hash with same keys as the apps have in config (I would put this in config). This is because running rake shops is slow enough to be annoying.
 - [ ] add -r,--refresh option to switch command to tell it to get fresh data
 - [ ] deploy apps with shopify_dev gem
@@ -102,6 +121,5 @@ https://github.com/cldwalker/bond
 
 
 # Using pry features
-https://github.com/ConradIrwin/pry-rescue
--- we **really** want to be using this in test/development environments in rails apps. 
+https://github.com/ConradIrwin/pry-rescue -- we **really** want to be using this in test/development environments in rails apps. 
 https://github.com/envygeeks/pry-vterm_aliases

data/lib/shopifydev/console.rb

@@ -1,4 +1,5 @@
 require 'shopifydev/pry/commands'
+require 'shopifydev/pry/save_json'
 require 'shopifydev/shopify_api/caches'
 
 require 'term/ansicolor'
@@ -13,3 +14,5 @@ class Color
     end
   end
 end
+
+Pry.config.hooks.add_hook(:before_session, :set_context) { |_, _, pry| pry.input = StringIO.new("cd ShopifyAPI") }

data/lib/shopifydev/pry/commands.rb

@@ -1,11 +1,179 @@
+# encoding: UTF-8
 require 'oj'
 
-class LocalShopifyApp
+class Switch
+  def initialize
+    @current_shop = ''
+    @menu = default_menu
+  end
+
+  def current_shop
+    @current_shop = ShopifyAPI::Base.site || 'none'
+    Color.green{ "current shop:"} + " #{@current_shop}"
+  end
+
+  def reset
+    @menu = default_menu
+  end
+
+  def menu
+    @menu
+  end
+
+  def pick(ix)
+    result = ''
+
+    # TODO we need need need to rename cfg, as it is currently confusing
+    @breadcrumbs, @cfg = pick_config(ix)
+
+    if @breadcrumbs == :no_such_config
+      result << Color.red{ "I don't know about #{ix}\n" }
+      result << self.menu.print
+    else
+      # update the menu based on the choice
+      # if we've reached a terminal menu, then do something
+      # otherwise just present the next menu
+      result << handle_choice
+    end
+  end
+
+  private
+
+  def set_shop(key, password, domain)
+    @current_shop = domain
+    ShopifyAPI::Base.site = "https://#{key}:#{password}@#{domain}/admin/"
+    @current_shop
+  end
+
+  def pick_config(ix)
+    # this gives us the menu item
+    path = self.menu.pick(ix)
+    return :no_such_config if path.nil?
+    result = shopify_config
+
+    path.each do |x|
+      result = result[x]
+    end
+
+    [path, result]
+  end
+
+  # if we chose a test shop cfg is a hash of key, password, and domain
+  # if we chose a local shop, it is a path
+  # path is the path through the yaml file
+  def handle_choice
+    result = ''
+
+    case @cfg.class.to_s
+    when "String" then
+      case @breadcrumbs[1].to_sym
+      when :development then menu_method = self.method(:development_menu)
+      when :heroku      then menu_method = self.method(:heroku_menu)
+      else                   menu_method = self.method(:missing_menu)
+      end
+    else result = handle_by_shop_type
+    end
+
+    if menu_method
+      result << "you picked #{@breadcrumbs.join('.')}\n"
+      result << @cfg.inspect + "\n"
+      result << Color.yellow { menu_method.call.print }
+    end
+    result
+  end
+
+  def handle_by_shop_type
+    if @cfg.keys.include?("shop_type")
+      result =  case @cfg["shop_type"].to_sym
+                when :local then "local"
+                when :heroku then "heroku"
+                else "something else"
+                end
+    else
+      set_shop(@cfg[:api_key], @cfg[:password], @cfg[:myshopify_domain])
+      result = self.current_shop
+    end
+
+    result
+  end
+
+  def default_menu
+    @menu = ConfigMenu.new(Shopifydev::Config.config, :default).build
+  end
+
+  # TODO this needs to be renamed:
+  #   It is the contents of .shopifydev.yaml, but it is also
+  #   more than that, since it gets updated throughout the life
+  #   of a switch object.
+  def shopify_config
+    @shopify_config ||= Shopifydev::Config.config
+  end
+
+  # TODO this method is pretty obscure
+  def development_menu
+    # this needs to be memoized
+    app = LocalShopifyApp.new(@cfg)
+    shops = app.shops
+
+    # add the shop_type to the array of shops
+    shops.each do |shop|
+      shop["shop_type"] = "local"
+    end
+
+    key = ''
+    domain = @cfg # at this point we know @cfg is a path on the local machine
+
+    # iterate over shopifydev.yaml and replace the local file path matching
+    # domain with the list of shops associated with that domain
+    # TODO drop M's terrible habbit of using k and v for key and value
+    shopify_config["apps"]["development"].each do |k, v|
+      if v == domain
+        shopify_config["apps"]["development"][k] = shops
+        key = k
+        break
+      end
+    end
+
+    # the menu relevant yaml needs to be [key, array]
+    @menu = ConfigMenu.new([key, shopify_config["apps"]["development"][key]], :development).build
+  end
+
+  def heroku_menu
+    app = HerokuShopifyApp.new(@cfg)
+    shops = app.shops
+    @menu = ConfigMenu.new(shops, :heroku).build
+  end
+
+  def missing_menu
+    @menu = ConfigMenu.new(shops, :missing).build
+  end
+end
+
+class Pry
+  attr_accessor :switch
+
+  def switch
+    @switch ||= Switch.new
+  end
+end
+
+# these mini classes JUST grabs the JSON that we need for making submenus
+class ShopifyAppShopList
   attr_accessor :path
+
   def initialize(path)
     @path = path
   end
 
+  def shops
+    raise "you must define the shops method"
+  end
+end
+
+class HerokuShopifyApp < ShopifyAppShopList
+end
+
+class LocalShopifyApp < ShopifyAppShopList
   def shops
     json = `/bin/bash -l -c "unset BUNDLE_GEMFILE; cd #{path} 2> /dev/null; bundle exec rake shops 2>/dev/null"`
     json = json.split("----snip----\n").last
@@ -15,65 +183,94 @@ class LocalShopifyApp
 end
 
 class ConfigMenu
-  attr_accessor :cfg
+  attr_accessor :json
 
-  def initialize(cfg)
-    @cfg = cfg
-    @menu_choices = [:do_nothing]
-    @menu_display = []
+  def initialize(json, style=:default)
+    @json = json
+    @style = style
+    @choices = [:do_nothing]
+    @lines = []
   end
 
   def build
+    case @style
+    when :development then build_development
+    when :default then build_default
+    when :heroku then build_heroku
+    else build_missing
+    end
+  end
+
+  def print(output=nil)
+    if output.nil?
+      @lines.join("\n")
+    else
+      output.puts @lines.join("\n")
+    end
+  end
+
+  def pick(ix)
+    if ix >= @choices.length
+      nil
+    else
+      @choices[ix]
+    end
+  end
+
+  private
+
+  # instead of having infinite build_something methods, maybe we should have
+  # a way of passing in blocks, or something?
+  def build_default
     header("Test Shops")
-    cfg[:test_shops].keys.each do |k|
+    json[:test_shops].keys.each do |k|
       choice([:test_shops, k], k)
     end
-    
+
     header("Local Apps")
-    cfg[:apps][:development].each do |k, path|
+    json[:apps][:development].each do |k, path|
       choice([:apps, :development, k], path)
     end
 
     header("Heroku Apps")
-    cfg[:apps][:heroku].each do |k, name|
+    json[:apps][:heroku].each do |k, name|
       choice([:apps, :heroku, k], name)
     end
 
     self
   end
 
-  def print(output)
-    output.puts @menu_display.join("\n")
-  end
+  def build_development
+    header("Development Shops")
 
-  def header(label)
-    @menu_display << ''
-    @menu_display << Color.blue { label }
+    name = json.first
+    json.last.each_with_index do |h, index|
+      choice([:apps, :development, name, index], h["url"])
+    end
+
+    self
   end
 
-  def choice(path, value)
-    ix = @menu_choices.length
-    @menu_display << Color.yellow{ ix.to_s } + '. ' + value.to_s
-    @menu_choices[ix] = path
+  def build_missing
+    warn("AND I DON'T EVEN KNOW!")
+    self
   end
 
-  def pick(ix)
-    if ix >= @menu_choices.length
-      nil
-    else
-      @menu_choices[ix]
-    end
+  # TODO I think these three related methods could be moved into a module called "Writer" or something
+  def header(label)
+    @lines << ''
+    @lines << Color.blue { label }
   end
 
-  def pick_config(ix)
-    path = pick(ix)
-    return :no_such_config if path.nil?
-    result = cfg
-    path.each do |x|
-      result = result[x]
-    end
+  def warn(label)
+    @lines << ''
+    @lines << Color.red { label }
+  end
 
-    [path, result]
+  def choice(path, value)
+    ix = @choices.length
+    @lines << Color.yellow{ ix.to_s } + '. ' + value.to_s
+    @choices[ix] = path
   end
 end
 
@@ -81,99 +278,48 @@ shopifydev_command_set = Pry::CommandSet.new do
   create_command "switch" do
     description "switch shops"
 
-
     # opt is a Slop object, see https://github.com/injekt/slop/blob/master/README.md
     def options(opt)
     end
 
     def process
-      print_current_shop
-
-      config_menu = ConfigMenu.new(Shopifydev::Config.config).build
+      output.puts _pry_.switch.current_shop
 
       case true
       when args.empty?
-        config_menu.print(output)
+        _pry_.switch.reset # reset to the first menu page
+        output.puts _pry_.switch.menu.print
+        print "ima ask for input:"
+        choice = $stdin.gets
+        puts "you chose #{choice}"
       when (args.length == 1)
         ix = args.first.to_i
-        path, cfg = config_menu.pick_config(ix)
-        if path == :no_such_config
-          output.puts Color.red{ "I don't know about #{ix}" }
-          config_menu.print(output)
-        else
-          handle_choice(path, cfg)
-        end
-      end
-    end
-
-    def print_current_shop
-      current_shop = ShopifyAPI::Base.site || 'none'
-      output.puts Color.green{ "current shop:"} + " #{current_shop}"
-    end
-
-    def handle_choice(path, cfg)
-      case path.first.to_sym
-      when :test_shops
-        url = "https://#{cfg[:api_key]}:#{cfg[:password]}@#{cfg[:myshopify_domain]}/admin/"
-        ShopifyAPI::Base.site = url
-        print_current_shop
-      when :apps
-        case path[1].to_sym
-        when :development
-          output.puts "you picked #{path.join('.')}"
-          output.puts cfg.inspect
-          app = LocalShopifyApp.new(cfg)
-          output.puts Color.yellow{ app.shops.inspect }
-        when :heroku
-          output.puts "you picked #{path.join('.')}"
-          output.puts cfg.inspect
-
-          output.puts Color.yellow{ "but it's not ready yet!"}          
-        else
-          output.puts "you picked #{path.join('.')}"
-          output.puts cfg.inspect
-          output.puts Color.red{ "AND I DON'T EVEN KNOW!"}          
-        end
-      else
-        output.puts "you picked #{path.join('.')}"
-        output.puts cfg.inspect
-        output.puts Color.red{ "AND I DON'T EVEN KNOW!"}          
+        output.puts _pry_.switch.pick(ix)
       end
     end
+  end
 
-
-    def output_menu_choices(arr, ix=1)
-      my_ix = 0
-      arr.each do |item|
-        output.puts menu_choice(ix+my_ix, item.to_s)
-        my_ix +=1
+  create_command "arlog", "Turn ActiveResource logging on/off" do
+    def process
+      case  args.first
+      when 'off'
+        puts Color.black{"ActiveResource logging "} + Color.red{'off'}
+        ActiveResource::Base.logger = nil
+      else      
+        puts Color.black{"ActiveResource logging "} + Color.yellow{'on'}
+        ActiveResource::Base.logger = Logger.new STDOUT
       end
-      my_ix
     end
+  end
 
-    def menu_choice(ix, s)
-      Color.yellow{ ix.to_s } + '. ' + s.to_s
-    end
-
-    def menu_header(s)
-      Color.blue { s }
-    end
-
-    def write_menu(cfg) 
-      ix = 1
-      # output.puts "Test Shops"
-      output.puts menu_header("Test Shops")
-      ix += output_menu_choices(cfg[:test_shops].keys.sort, ix)
-
-      output.puts
-      output.puts menu_header("Local Apps")
-      ix += output_menu_choices(cfg[:apps][:development].keys.sort, ix)
+  block_command "tree", "display directory using unix 'tree'" do |path|
+    dir ||= Pathname.getwd
+    dir = Pathname.new(dir) unless dir.is_a?(Pathname)
+    puts Color.blue{ "listing #{dir}..."}
+    puts `cd #{dir.expand_path.to_s}; tree`.gsub(%r{(^[^\w]+)}, Color.black{'\1'})
 
-      output.puts
-      output.puts menu_header("Heroku Apps")
-      ix += output_menu_choices(cfg[:apps][:heroku].keys.sort, ix)
-    end
   end
+
 end
 
 Pry::Commands.import shopifydev_command_set

data/lib/shopifydev/pry/save_json.rb

@@ -0,0 +1,78 @@
+module Kernel
+  def save_json(obj, path=nil)
+    json = Oj.dump(obj, object:true, circular:true)
+    path = UnixTree.get_path(path, require: :file, new: true)
+    if path
+      puts Color.green{"writing json to #{path.to_s}..."}
+      File.open(path, 'w'){|f| f.write(json)}
+      true
+    else
+      false
+    end
+  end
+
+  def load_json(path=nil)
+    path = UnixTree.get_path(path, require: :file)
+    if path
+      puts Color.green{"loading json from #{path.to_s}..."}
+      Oj.load(path)
+    else
+      nil
+    end
+  end
+  
+end
+
+module UnixTree
+  class << self
+    def get_path(path, opts={})
+      path = Pathname.new(path) unless path.nil?
+      while path.nil? || !viable_path(path, opts) do
+        missing = nil
+        path.expand_path.descend{|p| unless p.exist?; missing = p; break; end} if path      
+        if missing
+          what = (missing == path) ? opts[:require].to_s : 'directory'
+          puts Color.red{ "couldn't find #{what} #{missing.to_s}" } 
+          missing = missing.dirname
+          print_tree missing
+
+        end 
+        print Color.yellow{ "enter path: "}
+        in_path = $stdin.gets.chomp
+        return nil if in_path == 'q'
+        unless in_path.blank?
+          in_path = Pathname(in_path)
+          path = missing if missing
+          path ||= Pathname.getwd
+          path = in_path.relative? ? path.join(in_path) : in_path
+        end
+      end   
+      path.expand_path
+    end
+
+    def viable_path(path, opts={})
+      path = Pathname(path) unless path.is_a?(Pathname)
+      if opts[:new]
+        return false unless path.dirname.expand_path.exist?
+      else
+        return false unless path.expand_path.exist?
+      end
+      case opts[:require]
+      when :file
+        opts[:new] ? !(path.exist? && path.directory?) : path.expand_path.file?
+      when :directory
+        opts[:new] ? !path.exist? : path.expand_path.directory?
+      else
+        true
+      end
+    end
+
+    def print_tree(path=nil)
+      path ||= Pathname.getwd
+      path = Pathname.new(path) unless path.is_a?(Pathname)
+      path = path.dirname if path.file?
+      puts Color.blue{ "listing #{path}..."}
+      puts `cd #{path.expand_path.to_s}; tree`.gsub(%r{(^[^\w]+)}, Color.black{'\1'})
+    end
+  end
+end

data/lib/shopifydev/shopify_api/caches.rb

@@ -1,5 +1,3 @@
-puts "yo, included"
-
 module Shopifydev
   module ShopifyAPI
     module DirtyCache

data/lib/shopifydev/version.rb

@@ -1,3 +1,3 @@
 module Shopifydev
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shopifydev
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -222,6 +222,7 @@ files:
 - lib/shopifydev/generators/templates/rvmrc
 - lib/shopifydev/generators/templates/shopify-tmbundle
 - lib/shopifydev/pry/commands.rb
+- lib/shopifydev/pry/save_json.rb
 - lib/shopifydev/railtie.rb
 - lib/shopifydev/shop.rb
 - lib/shopifydev/shopify_api/caches.rb
@@ -249,7 +250,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -20439056481340104
+      hash: 3714550711815646135
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -258,7 +259,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -20439056481340104
+      hash: 3714550711815646135
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25