app_stack 1.3.4 → 1.4.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YzE2OTk2NTU4ZWJkMTc2ZDA2NmE4OWE4NGUwMjljY2RiNGQ4NTk1Mw==
+  data.tar.gz: !binary |-
+    MTUwYjA2OTYxYjk2NWEyNzk2YWExZmRiYTA0YTU0ZjViYTI0MTEzYw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YzFmOThkNzg5YmFiMTdlNzJhODU1ZTczM2JkN2U3NDlkYzQzYmFhMTZiNjdi
+    YTFmZTVjYzM3MjMzZmVmYjJjNGZjMGQ4YzQwODQwYzE1MDk0M2FjYWZlNTgw
+    YThjM2QxYzhhZTcyNTY5MTMyMTVmZjA0NWI1ZTY3MTEwODEzOTU=
+  data.tar.gz: !binary |-
+    ZWE1OWMzNDZiZTk3ZjdhYzBhMDU5MmFmZGYwYTNjM2Q2ZWYzZDVjOGVlZWQ5
+    ODM0YzVhNWQ3ODMzMzU4NzhjZWRhZThkMDhkMWI3NDQzYWQ2NjAyM2RjYWQ5
+    YTI3YWZiMjBjYTc4ODE4NTEwOTQ2ZGVmOWFhZWI3ZDg1YWUwZTc=

data/Gemfile

@@ -1,11 +1,12 @@
 source 'http://ruby.taobao.org'
 
 gem 'diffy'
-gem 'tilt', '>= 1.4.1'
-gem 'term-ansicolor', '>= 1.2.2'
-gem 'activesupport', '>= 3.2.14'
+gem 'tilt'
+gem 'term-ansicolor'
+gem 'activesupport'
 
 group :development, :test do
-  gem 'rspec', '>= 2.14.1'
-  gem 'simplecov', '>= 0.7.1'
+  gem 'rspec'
+  gem 'rubocop'
+  gem 'simplecov'
 end

data/Gemfile.lock

@@ -7,12 +7,18 @@ GEM
       multi_json (~> 1.3)
       thread_safe (~> 0.1)
       tzinfo (~> 0.3.37)
+    ast (1.1.0)
     atomic (1.1.13)
     diff-lcs (1.2.4)
     diffy (3.0.1)
     i18n (0.6.5)
     minitest (4.7.5)
     multi_json (1.8.0)
+    parser (2.0.0)
+      ast (~> 1.1)
+      slop (~> 3.4, >= 3.4.5)
+    powerpack (0.0.9)
+    rainbow (1.1.4)
     rspec (2.14.1)
       rspec-core (~> 2.14.0)
       rspec-expectations (~> 2.14.0)
@@ -21,10 +27,15 @@ GEM
     rspec-expectations (2.14.3)
       diff-lcs (>= 1.1.3, < 2.0)
     rspec-mocks (2.14.3)
+    rubocop (0.14.1)
+      parser (~> 2.0)
+      powerpack (~> 0.0.6)
+      rainbow (>= 1.1.4)
     simplecov (0.7.1)
       multi_json (~> 1.0)
       simplecov-html (~> 0.7.1)
     simplecov-html (0.7.1)
+    slop (3.4.6)
     term-ansicolor (1.2.2)
       tins (~> 0.8)
     thread_safe (0.1.2)
@@ -37,9 +48,10 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  activesupport (>= 3.2.14)
+  activesupport
   diffy
-  rspec (>= 2.14.1)
-  simplecov (>= 0.7.1)
-  term-ansicolor (>= 1.2.2)
-  tilt (>= 1.4.1)
+  rspec
+  rubocop
+  simplecov
+  term-ansicolor
+  tilt

data/README.md

@@ -4,6 +4,17 @@
 
 Import source files from a chain of application modules.
 
+## Parking list for new version (1.4)
+
+- Optional `.app_stack.yml` for stacked modules
+- Better detection for yaml file error
+- Better message with short file name
+- Render files only if contents really changed
+- <del datetime="2013-11-11T10:05:01 +0800">*new file only* mode</del>
+- <del datetime="2013-11-11T10:05:15 +0800">Better simulate, new file only, force mode</del>
+- Recursive stackup (?)
+- Separate sync/import group instead of one single `stackapps`
+
 ## Synposis
 
 Put a configuration file `.app_stack.yml` in your application
@@ -13,8 +24,9 @@ directory, in format like:
 
 The directory contains other modules to import.
 
-    stack:
+    import:
       - module-1
+    sync:
       - module-2: [defaults, tests]
       - module-3:
         - defaults

data/app_stack.gemspec

@@ -12,11 +12,12 @@ Gem::Specification.new 'app_stack', AppStack::VERSION do |s|
   s.license           = 'MIT'
   s.test_files        = Dir.glob('{spec,test}/**/*.rb')
 
-  s.add_dependency 'tilt', '>= 1.4.1'
-  s.add_dependency 'term-ansicolor', '>= 1.2.2'
-  s.add_dependency 'activesupport', '>= 3.2.14'
+  s.add_dependency 'tilt'
+  s.add_dependency 'term-ansicolor'
+  s.add_dependency 'activesupport'
   s.add_dependency 'diffy'
-  s.add_development_dependency 'rspec', '>= 2.14.1'
-  s.add_development_dependency 'simplecov', '>= 0.7.1'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rubocop'
+  s.add_development_dependency 'simplecov'
 end
 

data/lib/app_stack/app.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+module AppStack
+  # represent a single stacked application
+  class App
+    attr_accessor :rel_path
+    attr_reader :config, :conf_file, :app_stacks, :export_groups,
+                :sync_list, :import_list, :render_list,
+                :compare_list, :copy_list, :diff_list, :attrs
+
+    include AppStack::ConfigParser
+
+    def initialize(filename = nil, app_dir = nil)
+      @conf_file, @app_dir = filename, app_dir
+      @config = load_config
+      info 'loaded configuration: ', @config
+
+      @app_stacks = {}
+      @compare_list = []
+      @attrs = {}
+    end
+
+    # rubocop:disable MethodLength
+    def load_stack!
+      # load_stack.each ...
+      validate_config!
+
+      # parse all stacks
+      @import_list.merge(@sync_list).merge(@render_list).keys.each do |app|
+        app_dir = File.expand_path(app, File.join(directory, config.stack_dir))
+        # rubocop:disable LineLength
+        fail ParseError, "Error on #{@conf_file}, stack app #{app} not found in #{app_dir}" unless File.directory?(app_dir)
+        # rubocop:enable LineLength
+        @app_stacks[app] = App.new(AppStack.find_conf_file(app_dir), app_dir)
+        @app_stacks[app].rel_path = File.join(directory, config.stack_dir, app)
+        @app_stacks[app].parse_export_groups!
+        @attrs.merge! @app_stacks[app].config.attrs
+
+        # info "load app #{app.bold} as", @app_stacks[app]
+        info "load app #{app.bold}"
+      end
+
+      @attrs.merge! config.attrs
+      info 'merged attrs', attrs
+      @app_stacks
+    end
+    # rubocop:enable MethodLength
+
+    def stackup!
+      load_stack!
+      load_compare_list!
+      build_copy_list!
+      merge!
+    end
+
+    def options
+      AppStack.options
+    end
+
+    def directory
+      @app_dir ||= (conf_file && File.dirname(conf_file))
+      File.expand_path(@app_dir)
+    end
+
+    # use the direct name of the config file as app name
+    def app_name
+      directory && File.basename(directory)
+    end
+
+    # echo message only if verbose specified to be true
+    def info(msg, var = nil)
+      return unless options && options.verbose
+
+      msg = "[#{app_name || self.class.name}] ".green + msg
+      msg += "\n" if var && var.inspect.size > 30
+
+      print msg
+      if var
+        print Term::ANSIColor.bold
+        var.inspect.size > 30 ? PP.pp(var) : PP.singleline_pp(var)
+        print Term::ANSIColor.reset
+      end
+      puts unless var && var.inspect.size > 30
+    end
+  end
+end

data/lib/app_stack/cli_options.rb

@@ -2,51 +2,57 @@
 
 require 'optparse'
 
-# parse command line options based
-# rubocop:disable MethodLength
-class CliOptions
-  attr_accessor :force, :simulate, :verbose, :conf_file
-
-  def initialize(argv = ARGV)
-    parse_opt!(argv)
-    case argv.size
-    when 1 then self.conf_file = argv.shift
-    when 0 then self.conf_file = AppStack::DEFAULT_CONF_FILE
-    else fail "too many configuration files (#{argv.join(', ')})."
+module AppStack
+  # parse command line options based
+  # rubocop:disable MethodLength
+  class CliOptions
+    attr_accessor :force, :simulate, :verbose, :recursive, :conf_file
+
+    def initialize(argv = ARGV)
+      parse_opt!(argv)
+      case argv.size
+      when 1 then self.conf_file = argv.shift
+      when 0 then self.conf_file = nil
+      else fail "too many configuration files (#{argv.join(', ')})."
+      end
     end
-  end
 
-  # parse command line options
-  def parse_opt!(argv)
-    opt_parser = OptionParser.new do |opts|
-      opts.banner = 'Usage: appstack [options] [config_file]'
+    # parse command line options
+    def parse_opt!(argv)
+      opt_parser = OptionParser.new do |opts|
+        opts.banner = 'Usage: appstack [options] [config_file]'
 
-      opts.separator ''
-      opts.separator 'Available options:'
+        opts.separator ''
+        opts.separator 'Available options:'
 
-      opts.on('-f', '--force', 'force overwrite') do
-        self.force = true
-      end
+        opts.on('-f', '--force', 'force overwrite') do
+          self.force = true
+        end
 
-      opts.on('-s', '--simulate', 'simulate only, do not copy') do
-        self.simulate = true
-      end
+        opts.on('-s', '--simulate', 'simulate only, do not copy') do
+          self.simulate = true
+        end
 
-      opts.on('--verbose', 'show debug messages') do
-        self.verbose = true
-      end
+        opts.on('-r', '--recursive', 'recursively stackup all apps') do
+          self.recursive = true
+        end
 
-      opts.on_tail('-h', '--help', 'show this message') do
-        puts opts
-        exit
-      end
+        opts.on('--verbose', 'show debug messages') do
+          self.verbose = true
+        end
+
+        opts.on_tail('-h', '--help', 'show this message') do
+          puts opts
+          exit
+        end
 
-      opts.on_tail('-v', '--version', 'show version number') do
-        puts AppStack::VERSION
-        exit
+        opts.on_tail('-v', '--version', 'show version number') do
+          puts AppStack::VERSION
+          exit
+        end
       end
-    end
 
-    opt_parser.parse!(argv)
+      opt_parser.parse!(argv)
+    end
   end
 end

data/lib/app_stack/compare_list.rb

@@ -0,0 +1,195 @@
+# encoding: utf-8
+
+module AppStack
+
+  # items as copy list candidate
+  class CompareFile
+    attr_accessor :from_app, :from_file, :to_app, :to_file,
+                  :import, :render, :diff
+    def initialize(opts)
+      opts.each { |k, v| send("#{k}=".to_sym, v) }
+      @to_file ||= to_app.get_file_path(from_file_short_name)
+    end
+
+    def render?
+      render ? true : false
+    end
+
+    def import?
+      import ? true : false
+    end
+
+    def sync?
+      import ? false : true
+    end
+
+    def operation
+      return 'render' if render?
+      import? ? 'import' : 'sync'
+    end
+
+    def diff?
+      return true unless File.exists?(to_file)
+      c_file = from_file
+      if render?
+        c_file = Tempfile.new(File.basename(from_file)).path
+        render! c_file
+      end
+
+      @diff ||= Diffy::Diff.new(to_file, c_file, source: 'files')
+      @diff && @diff.to_s.chomp.size > 0 ? true : false
+    end
+
+    def local_new?
+      File.exists?(to_file) && File.mtime(to_file) > File.mtime(from_file)
+    end
+
+    def remote_new?
+      return true unless File.exists?(to_file)
+      File.mtime(from_file) > File.mtime(to_file)
+    end
+
+    def from_file_short_name
+      from_file.sub(/^#{from_app.directory}\//, '')
+    end
+
+    def to_file_short_name
+      to_file.sub(/^#{to_app.directory}\//, '')
+    end
+
+    def label
+      "#{operation} #{from_file_short_name.blue} from " +
+      "#{from_app.app_name.bold} as #{to_file_short_name.blue}"
+    end
+
+    def skip(msg)
+      "Skip #{operation} ".white + from_file_short_name.blue + ' from '.white +
+      from_app.app_name.bold + ': ' + msg
+    end
+
+    def process
+      render? ? render! : copy!
+    end
+
+    private
+
+    def render!(to = nil)
+      to ||= to_file
+      # return if @options.simulate
+      oh = File.open(to, 'wb')
+      if from_file.match(/\.liquid$/)
+        oh.write Liquid::Template
+          .parse(File.open(from_file, 'r:utf-8').read).render(to_app.attrs)
+      else
+        tilt = Tilt.new(from_file)
+        oh.write tilt.render(OpenStruct.new(to_app.attrs))
+      end
+      oh.close
+    end
+
+    def copy!
+      target_dir = File.dirname(to_file)
+      FileUtils.mkdir_p target_dir unless File.directory?(target_dir)
+      FileUtils.cp_r from_file, to_file
+    end
+
+  end
+
+  # reopen app class, extend with load_compare list function
+  class App
+    def load_compare_list!
+      # @import_list.merge(@sync_list).merge(@render_list
+      load_copy_list!(@import_list, import: true)
+      load_copy_list!(@sync_list)
+      load_render_list!(@render_list, render: true)
+      load_local_render_list!(render: true)
+    end
+
+    def load_copy_list!(list, opts = {})
+      list.each do |app, exp|
+        exp.each do |p| # string as group name or hash as file mapping
+          opts.merge! from_app: @app_stacks[app.to_s], to_app: self
+          p.is_a?(String) ? load_group!(p, opts) : load_file_map!(p, opts)
+        end
+      end
+    end
+
+    # rubocop:disable MethodLength
+    def load_render_list!(list, opts = {})
+      list.each do |appname, hsh|
+        app = @app_stacks[appname.to_s]
+        hsh.each do |fr, to|
+          to = fr.sub(/\.(erb|liquid|slim)$/, '') unless to.size > 0
+          from_file = app.get_file_path(fr)
+          if File.exists?(from_file)
+            @compare_list << CompareFile.new(
+              opts.merge(from_app: app, to_app: self,
+                         from_file: from_file,
+                         to_file: get_file_path(to)))
+          else
+            warn "[WARN] #{fr.blue} not found in #{app.app_name.bold}, skip."
+          end
+        end
+      end
+    end
+
+    def load_local_render_list!(opts = {})
+      config.render_local.each do |fr, to|
+        from_file = get_file_path(fr)
+        if File.exists?(from_file)
+          @compare_list << CompareFile.new(
+            opts.merge(from_app: self, to_app: self,
+                       from_file: from_file, to_file: get_file_path(to)))
+        else
+          warn "[WARN] #{fr.blue} not found in #{app_name.bold} (local), skip."
+        end
+      end
+    end
+
+    # rubocop:disable LineLength
+    def load_group!(group, opts)
+      app = opts[:from_app]
+      fail ParseError, "Error on #{@conf_file}, #{app.app_name.bold} did not export group #{group.bold}" unless app.export_groups[group.to_s]
+      app.get_group_files(group, opts[:from_app]).each do |full_path|
+        @compare_list << CompareFile.new(opts.merge(from_file: full_path))
+      end
+    end
+
+    def load_file_map!(hsh, opts)
+      hsh.each do |f, t|
+        t = f unless t && t.size > 0
+        from_file = opts[:from_app].get_file_path(f)
+        if File.exists?(from_file)
+          @compare_list << CompareFile.new(
+            opts.merge(from_file: opts[:from_app].get_file_path(f),
+                       to_file: opts[:to_app].get_file_path(t)))
+        else
+          warn "[WARN] #{f.blue} not found in #{opts[:from_app].app_name.bold}, skip."
+        end
+      end
+    end
+
+    def get_group_files(group, app)
+      file_list = []
+      export_groups[group.to_s].each do |fp|
+        if fp.match(/[\?\*\+\{\}]+/)
+          Dir[get_file_path(fp)].each { |f| file_list << f }
+        else
+          file = get_file_path(fp)
+
+          if File.exists?(file)
+            file_list << file
+          else
+            warn "[WARN] #{fp.blue} not found for #{app.app_name.bold}, group #{group.bold}, skip."
+          end
+        end
+      end
+      file_list
+    end
+    # rubocop:enable LineLength, MethodLength
+
+    def get_file_path(fp)
+      File.expand_path(fp, directory)
+    end
+  end
+end

data/lib/app_stack/configuration.rb

@@ -0,0 +1,119 @@
+# encoding: utf-8
+
+module AppStack
+  class ParseError < ArgumentError; end
+
+  # configuration from yaml file
+  class Configuration
+    attr_accessor :import, :sync, :export, :exclude, :render, :render_local,
+                  :attrs, :stack_dir
+
+    # rubocop:disable LineLength
+    def initialize(filename = nil)
+      # use yaml file to set configuration
+      config = default_config.dup
+      YAML.load(File.open(filename, 'r:utf-8').read).each do |k, v|
+        fail ParseError, "unkown option `#{k}` in #{filename}" unless default_config[k.to_sym]
+        fail ParseError, "'#{k}' must be a #{default_config[k.to_sym].class.to_s}" unless v.is_a?(default_config[k.to_sym].class)
+        config[k.to_sym] = v
+      end if filename
+
+      config.each { |k, v| send("#{k}=", v) }
+    end
+    # rubocop:enable LineLength
+
+    def default_config
+      {
+        import: [],
+        sync: [],
+        render: [],
+        render_local: {},
+        export: [],
+        exclude: [],
+        attrs: {},
+        stack_dir: '..'
+      }
+    end
+  end
+
+  # reopen App, mixin
+  module ConfigParser
+    def load_config
+      info 'load configuration file from:', @conf_file
+      Configuration.new(@conf_file)
+    end
+
+    def validate_config!
+      parse_export_groups!
+      @sync_list = parse_stack_list!('sync')
+      info 'load sync list as', @sync_list
+      @import_list = parse_stack_list!('import')
+      info 'load import list as', @import_list
+      @render_list = parse_render_list!
+
+      # rubocop:disable LineLength
+      config.exclude.each { |f| fail "Error on #{@conf_file} for exclude settings, #{f.inspect} is not a String" unless f.is_a?(String) }
+    end
+
+    # rubocop:disable LineLength, MethodLength
+    def parse_export_groups!
+      @export_groups = { 'default' => [] }
+      config.export.each do |exp|
+        case
+        when exp.is_a?(Hash) then @export_groups.merge!(exp)
+        when exp.is_a?(String) then @export_groups['default'] << exp
+        else fail ParseError, "Error on #{@conf_file}, wrong type for export: '#{exp.inspect}'"
+        end
+      end
+
+      # validate export file list format
+      @export_groups.each do |gname, list|
+        fail ParseError, "Error on #{@conf_file}, group name must be an String, not #{gname}" unless gname.is_a?(String)
+        fail ParseError, "Error on #{@conf_file} export group #{gname}, export files should be defined as a Array of String, #{list} is not an array." unless list.is_a?(Array)
+        list.each { |f| fail ParseError, "Error on #{@conf_file} export group #{gname}, export files should be defined as a Array of string, not #{f}" unless f.is_a?(String) }
+      end
+      @export_groups
+    end
+
+    private
+
+    def parse_stack_list!(list_type)
+      hlist = {}
+      config.send(list_type.to_sym).each do |exp|
+        case
+        when exp.is_a?(String) then # exp is the app name with default group
+          hlist[exp] = ['default']
+        when exp.is_a?(Hash)
+          exp.each do |app, list|
+            fail ParseError, "Error on #{@conf_file}, #{list_type} group, #{app} is not a String" unless app.is_a?(String)
+            fail ParseError, "Error on #{@conf_file}, #{list_type} group, #{list} is not a Array" unless list.is_a?(Array)
+            list.each do |g|
+              fail ParseError, "Error on #{@conf_file}, #{app} in #{list_type}, #{g} should be an String (file group) or a Hash (file mapping)" unless g.is_a?(Hash) || g.is_a?(String)
+            end
+          end
+          hlist.merge!(exp)
+        else fail ParseError, "Error on #{@conf_file}, #{list_type} group, should be an array of String or Hash." unless list.is_a?(Array)
+        end
+      end
+      hlist
+    end
+
+    def parse_render_list!
+      hlist = {}
+      config.render.each do |exp|
+        fail ParseError, "Error on #{@conf_file}, render group, #{exp.inspect} is not a Hash" unless exp.is_a?(Hash)
+        exp.each do |app, list|
+          fail ParseError, "Error on #{@conf_file}, #{list_type} group, #{app} is not a String" unless app.is_a?(String)
+          fail ParseError, "Error on #{@conf_file}, render for #{app}, #{list.inspect} is not a Hash" unless list.is_a?(Hash)
+          list.each do |fr, to|
+            fail ParseError, "Error on #{@conf_file}, render for #{app}, #{fr.inspect} is not a String" unless fr.is_a?(String)
+            fail ParseError, "Error on #{@conf_file}, render for #{app}, #{to.inspect} is not a String" unless to.is_a?(String)
+          end
+        end
+        hlist.merge! exp
+      end
+      hlist
+    end
+    # rubocop:enable LineLength
+  end
+end

data/lib/app_stack/operator.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+module AppStack
+  # mixin app class for build copy list
+  # rubocop:disable MethodLength
+  class App
+    def build_copy_list!
+      @copy_list, @diff_list = [], []
+      compare_list.each do |f|
+        info f.label
+        if File.exists?(f.to_file)
+          if f.import?
+            info f.skip('target exists')
+            next
+          end
+
+          if f.diff?
+            info f.label, 'add to diff list'
+            @diff_list << f
+          else
+            info f.skip('not changed')
+            next
+          end
+        end
+        info f.label, 'add to copy list'
+        @copy_list << f
+      end
+    end
+
+    def merge!
+      case
+      when AppStack.options.force then do_copy!
+      when AppStack.options.simulate then do_simulate!
+      else diff_list.size > 0 ? do_warn : do_copy!
+      end
+    end
+
+    private
+
+    def do_copy!
+      @copy_list.map(&:process)
+    end
+
+    def do_simulate!
+      @copy_list.each { |f| puts f.label }
+    end
+
+    def do_warn
+      puts 'These files are changed remotely:'
+      i = 1
+      @diff_list.each do |f|
+        puts "[#{i.to_s.bold}] " + f.to_file_short_name.blue
+        puts "from: #{f.from_file_short_name.blue}"
+        puts f.diff.to_s(:color)
+        i += 1
+      end
+      puts 'use -f (--force) option to overwrite all files.'
+    end
+  end
+end